package com.sg.service.biz.app.impl;

import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.collection.CollectionUtil;
import com.sg.common.util.CommonFunctionHelper;
import com.sg.common.util.RedisUtil;
import com.sg.dto.base.app.req.*;
import com.sg.dto.biz.app.req.*;
import com.sg.dto.biz.app.res.*;
import com.sg.dto.integration.calc.QueryStandardDataDetailComReqDto;
import com.sg.dto.integration.calc.QueryStandardDataDetailComRespDto;
import com.sg.dto.integration.framework.QueryAppDetailComReqDto;
import com.sg.dto.integration.framework.QueryAppDetailComRespDto;
import com.sg.service.biz.app.*;
import com.sg.common.exception.Assert;
import com.wicket.okrapp.common.exception.BizException;
import com.wicket.okrapp.dal.po.mbg.*;
import com.wicket.okrcalc.integration.FwCalcCalculationRulesClient;
import com.wicket.okrcalc.integration.GridCalculateService;
import com.wicket.okrcalc.integration.StandardDataService;
import com.wicket.okrcalc.integration.dto.*;
import com.wicket.okrcomponent.integration.ConfSchemeService;
import com.wicket.okrcomponent.integration.DivineDataService;
import com.wicket.okrcomponent.integration.InterfaceModeService;
import com.wicket.okrcomponent.integration.TemplateEngineService;
import com.wicket.okrcomponent.integration.dto.*;
import com.wicket.okrframework.integration.BaseService;
import org.apache.skywalking.apm.toolkit.trace.Tag;
import org.apache.skywalking.apm.toolkit.trace.Tags;
import org.apache.skywalking.apm.toolkit.trace.Trace;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;

/**
 * @author ：
 * @version 1.0
 * @date ：
 */
@Service
public class GridCalculateServiceImpl
        implements com.wicket.okrapp.biz.service.GridCalculateService {

    @Resource
    private RedisUtil redisUtil;
    @Resource
    private MOmsExecuteCycleStageService mOmsExecuteCycleStageService;
    @Resource
    private StandardDataService fwCalcStandardDataClient;
    @Resource
    private MOmsTspeCycleStageDataService mOmsTspeCycleStageDataService;
    @Resource
    private MOmsStandardDataResultService mOmsStandardDataResultService;
    //@Resource
    //private undefinedService undefinedService;
    @Resource
    private TargetContentService targetContentService;
    @Resource
    private GridCalculateService fwCalcGridCalculateClient;
    //@Resource
    //private MCustomFields3Service mCustomFields3Service;
    @Resource
    private MOmsCycleService mOmsCycleService;
    @Resource
    private MOmsEvaluationObjectTargetCycleService mOmsEvaluationObjectTargetCycleService;
    @Resource
    private NbGridCalculate nbGridCalculate;
    @Resource
    private InterfaceModeService interfaceModeService;
    @Resource
    private MOmsTaskService mOmsTaskService;
    @Resource
    private DivineDataService fwCompDivineDataClient;
    @Resource
    private TaskService taskService;
    @Resource
    private TargetCycleService targetCycleService;
    @Resource
    private ConfSchemeService confSchemeService;
    @Resource
    private MOmsTargetTimingTaskDispatchService mOmsTargetTimingTaskDispatchService;
    @Resource
    private MOmsEvaBatchRelatedSetService mOmsEvaBatchRelatedSetService;
    @Resource
    private CycleStageDataService cycleStageDataService;
    @Resource
    private FwCalcCalculationRulesClient fwCalcCalculationRulesClient;
    @Resource
    private MOmsEvaluationTemplateService mOmsEvaluationTemplateService;
    @Resource
    private MOmsTargetCategoryExtendService mOmsTargetCategoryExtendService;
    @Resource
    private MOmsTargetObjectivePlanExtendService mOmsTargetObjectivePlanExtendService;
    @Resource
    private ExecuteProgressService executeProgressService;
    @Resource
    private TaskGenService taskGenService;
    @Resource
    private ProgressPublicTechnicaCapacityService progressPublicTechnicaCapacityService;
    @Resource
    private MOmsExecuteProgressService mOmsExecuteProgressService;
    @Resource
    private BaseService baseService;
    @Resource
    private TemplateEngineService fwCompTemplateEngineClient;
    @Resource
    private InterfaceModeService interfaceModeService;
    @Resource
    private IndexSystemService indexSystemService;
    @Resource
    private ExecuteCycleService executeCycleService;
    @Resource
    private MessageService messageService;

    /**
     * D3-获取过程中期标准数据(公共)[6463]
     * gen by moon at 7/4/2023, 6:22:42 PM
     */
    @Trace(operationName = "D3-获取过程中期标准数据(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ObtainMidProgressCycleStaDataComRespDto obtainMidProgressCycleStaDataCom(ObtainMidProgressCycleStaDataComReqDto reqDto) {


        QueryStandardDataDetailComRespDto queryStandardDataDetailComRespDto_1 = null;
//virtualUsage 3-3-07查询执行周期阶段详情  39581
        OmsExecuteCycleStage omsExecuteCycleStage = null;
        QueryExecuteCycleStageDetailReq queryExecuteCycleStageDetailReq = new QueryExecuteCycleStageDetailReq();
        queryExecuteCycleStageDetailReq.setIsProcessCycleStage("TRUE");//sourceId:887677_1_39581
        queryExecuteCycleStageDetailReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:887676_1_39581
        if (reqDto != null) {
            queryExecuteCycleStageDetailReq.setCycleStartTime(reqDto.getCycleStartTime());//SimpleFieldAssign//sourceId:887673_1_39581
            queryExecuteCycleStageDetailReq.setCycleTypeCode(reqDto.getCycleTypeCode());//SimpleFieldAssign//sourceId:887674_1_39581
            queryExecuteCycleStageDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:887675_1_39581
        }

        /*3-3-07查询执行周期阶段详情[2429]   */
        Assert.isNull(queryExecuteCycleStageDetailReq.getCycleStartTime(), "D3-获取过程中期标准数据(公共)-3-3-07查询执行周期阶段详情-周期开始时间不能为空", false);
        Assert.isNull(queryExecuteCycleStageDetailReq.getIsProcessCycleStage(), "D3-获取过程中期标准数据(公共)-3-3-07查询执行周期阶段详情-是否过程周期阶段不能为空", false);
        Assert.isNull(queryExecuteCycleStageDetailReq.getEvaluationTemplateId(), "D3-获取过程中期标准数据(公共)-3-3-07查询执行周期阶段详情-评价模板ID不能为空", false);
        Assert.isNull(queryExecuteCycleStageDetailReq.getSubjectLifeCycle(), "D3-获取过程中期标准数据(公共)-3-3-07查询执行周期阶段详情-主体生命周期不能为空", false);
        omsExecuteCycleStage = mOmsExecuteCycleStageService.queryExecuteCycleStageDetail(queryExecuteCycleStageDetailReq)/*vcase invoke 本地 method 方法调用;*/;


        if ((omsExecuteCycleStage != null)) {
            //if(3-3-07查询执行周期阶段详情.出参 值不等于空 )  39582

            QueryStandardDataDetailComRespDto queryStandardDataDetailComRespDto = null;
            if (omsExecuteCycleStage != null) {
                QueryStandardDataDetailComReqDto queryStandardDataDetailComReqDto = new QueryStandardDataDetailComReqDto();
                queryStandardDataDetailComReqDto.setTableTypeCode("OMS_EVALUATION_OBJECT_TARGET_CYCLE");//sourceId:887684_1_39583
                queryStandardDataDetailComReqDto.setDataUsageSceneCode("TARGET_PLAN_CALC_DATA_STATISTICS");//sourceId:1077348_1_39583
                queryStandardDataDetailComReqDto.setIsArchive("FALSE");//sourceId:887687_1_39583
                queryStandardDataDetailComReqDto.setIsNewData("TRUE");//sourceId:887688_1_39583
                queryStandardDataDetailComReqDto.setThemeContentTypeCode("OMS_EVALUATION_TEMPLATE");//sourceId:887689_1_39583
                if (omsExecuteCycleStage != null) {
                    queryStandardDataDetailComReqDto.setPeriodId(omsExecuteCycleStage.getCycleId());//SimpleFieldAssign//sourceId:887683_1_39583
                }
                if (reqDto != null) {
                    queryStandardDataDetailComReqDto.setEntityId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:887685_1_39583
                    queryStandardDataDetailComReqDto.setDataType(reqDto.getDataType());//SimpleFieldAssign//sourceId:887686_1_39583
                    queryStandardDataDetailComReqDto.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:887690_1_39583
                }

                /*D4-1查标准数据详情(公共)[2695]   */
                Assert.isNull(queryStandardDataDetailComReqDto.getPeriodId(), "D3-获取过程中期标准数据(公共)-D4-1查标准数据详情(公共)-周期ID不能为空", false);
                Assert.isNull(queryStandardDataDetailComReqDto.getTableTypeCode(), "D3-获取过程中期标准数据(公共)-D4-1查标准数据详情(公共)-归属内容表类型编码不能为空", false);
                Assert.isNull(queryStandardDataDetailComReqDto.getEntityId(), "D3-获取过程中期标准数据(公共)-D4-1查标准数据详情(公共)-归属内容表主键ID不能为空", false);
                Assert.isNull(queryStandardDataDetailComReqDto.getDataType(), "D3-获取过程中期标准数据(公共)-D4-1查标准数据详情(公共)-数据点类型不能为空", false);
                Assert.isNull(queryStandardDataDetailComReqDto.getDataUsageSceneCode(), "D3-获取过程中期标准数据(公共)-D4-1查标准数据详情(公共)-数据业务场景不能为空", false);
                Assert.isNull(queryStandardDataDetailComReqDto.getIsArchive(), "D3-获取过程中期标准数据(公共)-D4-1查标准数据详情(公共)-是否存档不能为空", false);
                Assert.isNull(queryStandardDataDetailComReqDto.getIsNewData(), "D3-获取过程中期标准数据(公共)-D4-1查标准数据详情(公共)-是否归属周期最新数据不能为空", false);
                Assert.isNull(queryStandardDataDetailComReqDto.getThemeContentTypeCode(), "D3-获取过程中期标准数据(公共)-D4-1查标准数据详情(公共)-主题内容类型编码不能为空", false);
                Assert.isNull(queryStandardDataDetailComReqDto.getThemeContentId(), "D3-获取过程中期标准数据(公共)-D4-1查标准数据详情(公共)-主题内容ID不能为空", false);
                queryStandardDataDetailComRespDto = fwCalcStandardDataClient.queryStandardDataDetailCom(queryStandardDataDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


                queryStandardDataDetailComRespDto_1 = queryStandardDataDetailComRespDto;
            }
        }
        ObtainMidProgressCycleStaDataComRespDto retData = new ObtainMidProgressCycleStaDataComRespDto();
        if (queryStandardDataDetailComRespDto_1 != null) {
            retData.setDataResultId(queryStandardDataDetailComRespDto_1.getDataResultId());//SimpleFieldAssign//sourceId:887695_1
            retData.setDataResult(queryStandardDataDetailComRespDto_1.getDataResult());//SimpleFieldAssign//sourceId:887696_1
        }


        return retData;
    }

    /**
     * D3-分析目标周期是否满足托底计算(公共)[6502]
     * gen by moon at 10/15/2023, 3:36:02 AM
     */
    @Trace(operationName = "D3-分析目标周期是否满足托底计算(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementTargetCycleCanExecuteUnderpinningCalcComRespDto implementTargetCycleCanExecuteUnderpinningCalcCom(ImplementTargetCycleCanExecuteUnderpinningCalcComReqDto reqDto) {


        OmsEvaluationObjectTargetCycle omsEvaluationObjectTargetCycle_1 = null;
        CalculateAcceptAboveFieldsRespDto receptionServiceRes_5 = null;
//virtualUsage 满足循环发牌  40241
        //ModelCode: receptionService
        CalculateAcceptAboveFieldsRespDto receptionServiceRes = null;
        CalculateAcceptAboveFieldsReqDto receptionServiceReq = new CalculateAcceptAboveFieldsReqDto();
        receptionServiceReq.setTureOrFalse("TRUE");//sourceId:901452_1_40241

        /*满足循环发牌[6495]  用于特殊方法接收上游入参。 */

        receptionServiceRes = nbGridCalculate.calculateAcceptAboveFields(receptionServiceReq);


//virtualUsage 不满足循环发牌  40242
        //ModelCode: receptionService
        CalculateAcceptAboveFieldsRespDto receptionServiceRes_2 = null;
        CalculateAcceptAboveFieldsReqDto receptionServiceReq_1 = new CalculateAcceptAboveFieldsReqDto();
        receptionServiceReq_1.setTureOrFalse("FALSE");//sourceId:901454_1_40242

        /*不满足循环发牌[6495]  用于特殊方法接收上游入参。 */

        receptionServiceRes_2 = nbGridCalculate.calculateAcceptAboveFields(receptionServiceReq_1);


//virtualUsage D3获取当前目标内容执行周期(公共)  49703
        ObtainCurrentTargetContexeCuteCycleComRespDto obtainCurrentTargetContexeCuteCycleComRespDto = null;
        ObtainCurrentTargetContexeCuteCycleComReqDto obtainCurrentTargetContexeCuteCycleComReqDto = new ObtainCurrentTargetContexeCuteCycleComReqDto();
        if (reqDto != null) {
            obtainCurrentTargetContexeCuteCycleComReqDto.setCycleId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:1163348_1_49703
            obtainCurrentTargetContexeCuteCycleComReqDto.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1163349_1_49703
            obtainCurrentTargetContexeCuteCycleComReqDto.setTargetId(reqDto.getTargetId());//SimpleFieldAssign//sourceId:1163350_1_49703
            obtainCurrentTargetContexeCuteCycleComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1163351_1_49703
        }

        /*D3获取当前目标内容执行周期(公共)[7501]   */
        Assert.isNull(obtainCurrentTargetContexeCuteCycleComReqDto.getCycleId(), "D3-分析目标周期是否满足托底计算(公共)-D3获取当前目标内容执行周期(公共)-周期ID不能为空", false);
        Assert.isNull(obtainCurrentTargetContexeCuteCycleComReqDto.getTargetCycleContentId(), "D3-分析目标周期是否满足托底计算(公共)-D3获取当前目标内容执行周期(公共)-关联目标内容ID不能为空", false);
        Assert.isNull(obtainCurrentTargetContexeCuteCycleComReqDto.getTargetId(), "D3-分析目标周期是否满足托底计算(公共)-D3获取当前目标内容执行周期(公共)-冗余目标ID不能为空", false);
        Assert.isNull(obtainCurrentTargetContexeCuteCycleComReqDto.getEvaluationTemplateId(), "D3-分析目标周期是否满足托底计算(公共)-D3获取当前目标内容执行周期(公共)-冗余评价模板ID不能为空", false);
        obtainCurrentTargetContexeCuteCycleComRespDto = executeCycleService.obtainCurrentTargetContexeCuteCycleCom(obtainCurrentTargetContexeCuteCycleComReqDto)/*vcase invoke isSameApp*/;


//virtualUsage 3-3-09查被评对象目标周期详情  40236
        OmsEvaluationObjectTargetCycle omsEvaluationObjectTargetCycle = null;
        if (obtainCurrentTargetContexeCuteCycleComRespDto != null) {
            QueryEvaObjTargetCycleDetailReq queryEvaObjTargetCycleDetailReq = new QueryEvaObjTargetCycleDetailReq();
            if (reqDto != null) {
                queryEvaObjTargetCycleDetailReq.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:901418_1_40236
                queryEvaObjTargetCycleDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:901421_1_40236
            }
            if (obtainCurrentTargetContexeCuteCycleComRespDto != null) {
                queryEvaObjTargetCycleDetailReq.setCycleStartTime(obtainCurrentTargetContexeCuteCycleComRespDto.getCycleStartTime());//SimpleFieldAssign//sourceId:901419_1_40236
                queryEvaObjTargetCycleDetailReq.setCycleEndTime(obtainCurrentTargetContexeCuteCycleComRespDto.getCycleEndTime());//SimpleFieldAssign//sourceId:901420_1_40236
            }

            /*3-3-09查被评对象目标周期详情[2313]   */
            Assert.isNull(queryEvaObjTargetCycleDetailReq.getEvaObjTargetCycleId(), "D3-分析目标周期是否满足托底计算(公共)-3-3-09查被评对象目标周期详情-被评对象目标周期ID不能为空", false);
            Assert.isNull(queryEvaObjTargetCycleDetailReq.getCycleStartTime(), "D3-分析目标周期是否满足托底计算(公共)-3-3-09查被评对象目标周期详情-目标计划开始时间不能为空", false);
            Assert.isNull(queryEvaObjTargetCycleDetailReq.getCycleEndTime(), "D3-分析目标周期是否满足托底计算(公共)-3-3-09查被评对象目标周期详情-目标计划结束时间不能为空", false);
            Assert.isNull(queryEvaObjTargetCycleDetailReq.getEvaluationTemplateId(), "D3-分析目标周期是否满足托底计算(公共)-3-3-09查被评对象目标周期详情-冗余评价模板ID不能为空", false);
            omsEvaluationObjectTargetCycle = mOmsEvaluationObjectTargetCycleService.queryEvaObjTargetCycleDetail(queryEvaObjTargetCycleDetailReq)/*vcase invoke 本地 method 方法调用;*/;


            omsEvaluationObjectTargetCycle_1 = omsEvaluationObjectTargetCycle;
        }
        if ((omsEvaluationObjectTargetCycle != null)) {
            //if(3-3-09查目标周期详情（根据周期时间范围查询目标周期牌是否满足）.出参 值不等于空 )  40237

//ModelCode: receptionService
            CalculateAcceptAboveFieldsRespDto receptionServiceRes_4 = null;
            CalculateAcceptAboveFieldsReqDto receptionServiceReq_2 = new CalculateAcceptAboveFieldsReqDto();
            if (receptionServiceRes != null) {
                receptionServiceReq_2.setTureOrFalse(receptionServiceRes.getTureOrFalse());//SimpleFieldAssign//sourceId:901467_1_40238
            }

            /*约定出参：是否满足循环发牌[6495]  用于特殊方法接收上游入参。 */
            Assert.isNull(receptionServiceReq_2.getTureOrFalse(), "D3-分析目标周期是否满足托底计算(公共)-约定出参：是否满足循环发牌-是否不能为空", false);
            receptionServiceRes_4 = nbGridCalculate.calculateAcceptAboveFields(receptionServiceReq_2);


            receptionServiceRes_5 = receptionServiceRes_4;
        } else if ((omsEvaluationObjectTargetCycle == null)) {
            //elseif(3-3-09查目标周期详情（根据周期时间范围查询目标周期牌是否满足）.出参 值等于空 )  40239

//ModelCode: receptionService
            CalculateAcceptAboveFieldsRespDto receptionServiceRes_6 = null;
            CalculateAcceptAboveFieldsReqDto receptionServiceReq_3 = new CalculateAcceptAboveFieldsReqDto();
            if (receptionServiceRes_2 != null) {
                receptionServiceReq_3.setTureOrFalse(receptionServiceRes_2.getTureOrFalse());//SimpleFieldAssign//sourceId:901467_1_40240
            }

            /*约定出参：是否满足循环发牌[6495]  用于特殊方法接收上游入参。 */
            Assert.isNull(receptionServiceReq_3.getTureOrFalse(), "D3-分析目标周期是否满足托底计算(公共)-约定出参：是否满足循环发牌-是否不能为空", false);
            receptionServiceRes_6 = nbGridCalculate.calculateAcceptAboveFields(receptionServiceReq_3);


            receptionServiceRes_5 = receptionServiceRes_6;
        }
        ImplementTargetCycleCanExecuteUnderpinningCalcComRespDto retData = new ImplementTargetCycleCanExecuteUnderpinningCalcComRespDto();
        if (receptionServiceRes_5 != null) {
            retData.setTureOrFalse(receptionServiceRes_5.getTureOrFalse());//SimpleFieldAssign//sourceId:901485_1
        }
        if (omsEvaluationObjectTargetCycle_1 != null) {
            retData.setHaveProcessCycle(omsEvaluationObjectTargetCycle_1.getHaveProcessCycle());//SimpleFieldAssign//sourceId:901790_1
        }


        return retData;
    }


    /**
     * D3-执行自动汇报处理(公共)[6524]
     * gen by moon at 5/9/2023, 5:48:37 AM
     */
    @Trace(operationName = "D3-执行自动汇报处理(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementAutoReportComRespDto implementAutoReportCom(ImplementAutoReportComReqDto reqDto) {


        //virtualUsage 3-7-01查询任务详情  40535
        OmsTask omsTask = null;
        QueryTaskDetailReq queryTaskDetailReq = new QueryTaskDetailReq();
        queryTaskDetailReq.setIsComplete("FALSE");//sourceId:904285_1_40535
        queryTaskDetailReq.setIsAutoReport("TRUE");//sourceId:904284_1_40535
        if (reqDto != null) {
            queryTaskDetailReq.setTaskId(reqDto.getTaskId());//SimpleFieldAssign//sourceId:904274_1_40535
            queryTaskDetailReq.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:904275_1_40535
        }

        /*3-7-01查询任务详情[2522]   */
        Assert.isNull(queryTaskDetailReq.getTaskId(), "D3-执行自动汇报处理(公共)-3-7-01查询任务详情-任务ID不能为空", false);
        Assert.isNull(queryTaskDetailReq.getIsComplete(), "D3-执行自动汇报处理(公共)-3-7-01查询任务详情-是否完成不能为空", false);
        Assert.isNull(queryTaskDetailReq.getIsAutoReport(), "D3-执行自动汇报处理(公共)-3-7-01查询任务详情-是否自动汇报不能为空", false);
        Assert.isNull(queryTaskDetailReq.getThemeContentId(), "D3-执行自动汇报处理(公共)-3-7-01查询任务详情-主题内容ID不能为空", false);
        omsTask = mOmsTaskService.queryTaskDetail(queryTaskDetailReq)/*vcase invoke 本地 method 方法调用;*/;


        if ((omsTask != null)) {
            //if(3-7-01查任务是否未完成且是自动汇报.出参 值不等于空 )  40536

            CheckTimeScopeSearchComRespDto checkTimeScopeSearchComRespDto = null;
            if (omsTask != null) {
                CheckTimeScopeSearchComReqDto checkTimeScopeSearchComReqDto = new CheckTimeScopeSearchComReqDto();
                checkTimeScopeSearchComReqDto.setCurrentTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:904286_1_40537
                if (omsTask != null) {
                    checkTimeScopeSearchComReqDto.setCompareTime(omsTask.getPlanEndTime());//SimpleFieldAssign//sourceId:904288_1_40537
                }

                /*D2检查时间范围查询(公共)[3297]   */
                Assert.isNull(checkTimeScopeSearchComReqDto.getCurrentTime(), "D3-执行自动汇报处理(公共)-D2检查时间范围查询(公共)-当前时间不能为空", false);
                Assert.isNull(checkTimeScopeSearchComReqDto.getCompareTime(), "D3-执行自动汇报处理(公共)-D2检查时间范围查询(公共)-比较时间不能为空", false);
                checkTimeScopeSearchComRespDto = fwCompDivineDataClient.checkTimeScopeSearchCom(checkTimeScopeSearchComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


            }
            if ((checkTimeScopeSearchComRespDto != null && checkTimeScopeSearchComRespDto.getTimeCompareResult() != null && checkTimeScopeSearchComRespDto.getTimeCompareResult().equals("PRESENT") || checkTimeScopeSearchComRespDto != null && checkTimeScopeSearchComRespDto.getTimeCompareResult() != null && checkTimeScopeSearchComRespDto.getTimeCompareResult().equals("LATER"))) {
                //if((D2-当前时间与任务结束时间比较.时间比较结果 等于 当前（等于） or D2-当前时间与任务结束时间比较.时间比较结果 等于 之后（大于）))  40538

                ImplementAnalysisIsPlanReceptionCycleComRespDto implementAnalysisIsPlanReceptionCycleComRespDto = null;
                ImplementAnalysisIsPlanReceptionCycleComReqDto implementAnalysisIsPlanReceptionCycleComReqDto = new ImplementAnalysisIsPlanReceptionCycleComReqDto();
                if (reqDto != null) {
                    implementAnalysisIsPlanReceptionCycleComReqDto.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:904289_1_40542
                    implementAnalysisIsPlanReceptionCycleComReqDto.setCycleId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:904290_1_40542
                    implementAnalysisIsPlanReceptionCycleComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:904291_1_40542
                }

                /*D3-执行分析当前是否验收周期(公共)[6139]   */
                Assert.isNull(implementAnalysisIsPlanReceptionCycleComReqDto.getEvaObjTargetCycleId(), "D3-执行自动汇报处理(公共)-D3-执行分析当前是否验收周期(公共)-被评对象目标周期ID不能为空", false);
                Assert.isNull(implementAnalysisIsPlanReceptionCycleComReqDto.getCycleId(), "D3-执行自动汇报处理(公共)-D3-执行分析当前是否验收周期(公共)-周期ID不能为空", false);
                Assert.isNull(implementAnalysisIsPlanReceptionCycleComReqDto.getEvaluationTemplateId(), "D3-执行自动汇报处理(公共)-D3-执行分析当前是否验收周期(公共)-冗余评价模板ID不能为空", false);
                implementAnalysisIsPlanReceptionCycleComRespDto = targetContentService.implementAnalysisIsPlanReceptionCycleCom(implementAnalysisIsPlanReceptionCycleComReqDto)/*vcase invoke isSameApp*/;


                ImplementReportingTaskInfoComRespDto implementReportingTaskInfoComRespDto = null;
                if (implementAnalysisIsPlanReceptionCycleComRespDto != null) {
                    ImplementReportingTaskInfoComReqDto implementReportingTaskInfoComReqDto = new ImplementReportingTaskInfoComReqDto();
                    implementReportingTaskInfoComReqDto.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:904188_1_40540
                    if (reqDto != null) {
                        implementReportingTaskInfoComReqDto.setCycleStageDataId(reqDto.getCycleStageDataId());//SimpleFieldAssign//sourceId:904193_1_40540
                        implementReportingTaskInfoComReqDto.setTaskId(reqDto.getTaskId());//SimpleFieldAssign//sourceId:904187_1_40540
                        implementReportingTaskInfoComReqDto.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:904190_1_40540
                        implementReportingTaskInfoComReqDto.setCycleId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:904191_1_40540
                        implementReportingTaskInfoComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:904189_1_40540
                    }
                    if (implementAnalysisIsPlanReceptionCycleComRespDto != null) {
                        implementReportingTaskInfoComReqDto.setIsActualReceptionCycle(implementAnalysisIsPlanReceptionCycleComRespDto.getIsPlanReceptionCycle());//SimpleFieldAssign//sourceId:904192_1_40540
                    }

                    /*D3-执行汇报任务资料正式提交处理(公共)[5489]   */
                    Assert.isNull(implementReportingTaskInfoComReqDto.getCycleStageDataId(), "D3-执行自动汇报处理(公共)-D3-执行汇报任务资料正式提交处理(公共)-周期阶段资料记录ID不能为空", false);
                    Assert.isNull(implementReportingTaskInfoComReqDto.getTaskId(), "D3-执行自动汇报处理(公共)-D3-执行汇报任务资料正式提交处理(公共)-任务ID不能为空", false);
                    Assert.isNull(implementReportingTaskInfoComReqDto.getEvaObjTargetCycleId(), "D3-执行自动汇报处理(公共)-D3-执行汇报任务资料正式提交处理(公共)-被评对象目标周期ID不能为空", false);
                    Assert.isNull(implementReportingTaskInfoComReqDto.getCycleId(), "D3-执行自动汇报处理(公共)-D3-执行汇报任务资料正式提交处理(公共)-周期ID不能为空", false);
                    Assert.isNull(implementReportingTaskInfoComReqDto.getSubjectLifeCycle(), "D3-执行自动汇报处理(公共)-D3-执行汇报任务资料正式提交处理(公共)-主体生命周期不能为空", false);
                    Assert.isNull(implementReportingTaskInfoComReqDto.getEvaluationTemplateId(), "D3-执行自动汇报处理(公共)-D3-执行汇报任务资料正式提交处理(公共)-冗余评价模板ID不能为空", false);
                    implementReportingTaskInfoComRespDto = taskService.implementReportingTaskInfoCom(implementReportingTaskInfoComReqDto)/*vcase invoke isSameApp*/;


                }
                UpdateEvaObjTargetCycleComRespDto updateEvaObjTargetCycleComRespDto = null;
                UpdateEvaObjTargetCycleComReqDto updateEvaObjTargetCycleComReqDto = new UpdateEvaObjTargetCycleComReqDto();
                if (reqDto != null) {
                    updateEvaObjTargetCycleComReqDto.setCycleStageDataId(reqDto.getCycleStageDataId());//SimpleFieldAssign//sourceId:904201_1_40541
                    updateEvaObjTargetCycleComReqDto.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:904199_1_40541
                    updateEvaObjTargetCycleComReqDto.setCycleId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:904204_1_40541
                    updateEvaObjTargetCycleComReqDto.setTargetCycleContentTypeCode(reqDto.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:904202_1_40541
                    updateEvaObjTargetCycleComReqDto.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:904203_1_40541
                    updateEvaObjTargetCycleComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:904200_1_40541
                }

                /*D3-3修改被评对象目标周期进展状态(公共)[3910]   */
                Assert.isNull(updateEvaObjTargetCycleComReqDto.getCycleStageDataId(), "D3-执行自动汇报处理(公共)-D3-3修改被评对象目标周期进展状态(公共)-周期阶段资料记录ID不能为空", false);
                Assert.isNull(updateEvaObjTargetCycleComReqDto.getEvaObjTargetCycleId(), "D3-执行自动汇报处理(公共)-D3-3修改被评对象目标周期进展状态(公共)-被评对象目标周期ID不能为空", false);
                Assert.isNull(updateEvaObjTargetCycleComReqDto.getCycleId(), "D3-执行自动汇报处理(公共)-D3-3修改被评对象目标周期进展状态(公共)-周期ID不能为空", false);
                Assert.isNull(updateEvaObjTargetCycleComReqDto.getTargetCycleContentTypeCode(), "D3-执行自动汇报处理(公共)-D3-3修改被评对象目标周期进展状态(公共)-关联目标内容类型编码不能为空", false);
                Assert.isNull(updateEvaObjTargetCycleComReqDto.getTargetCycleContentId(), "D3-执行自动汇报处理(公共)-D3-3修改被评对象目标周期进展状态(公共)-关联目标内容ID不能为空", false);
                Assert.isNull(updateEvaObjTargetCycleComReqDto.getEvaluationTemplateId(), "D3-执行自动汇报处理(公共)-D3-3修改被评对象目标周期进展状态(公共)-冗余评价模板ID不能为空", false);
                updateEvaObjTargetCycleComRespDto = targetCycleService.updateEvaObjTargetCycleCom(updateEvaObjTargetCycleComReqDto)/*vcase invoke isSameApp*/;


            }
        }
        ImplementAutoReportComRespDto retData = new ImplementAutoReportComRespDto();


        return retData;
    }

    /**
     * D3-执行回写是否自动汇报(公共)[6541]
     * gen by moon at 4/24/2024, 4:07:31 PM
     */
    @Trace(operationName = "D3-执行回写是否自动汇报(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementWriteBackTaskAutoReportComRespDto implementWriteBackTaskAutoReportCom(ImplementWriteBackTaskAutoReportComReqDto reqDto) {


        //virtualUsage D3-执行标准数据计算周期模型分析(公共)  40802
        ImplementCurrentCycleTypeAnalysisNoCalcComRespDto implementCurrentCycleTypeAnalysisNoCalcComRespDto = null;
        ImplementCurrentCycleTypeAnalysisNoCalcComReqDto implementCurrentCycleTypeAnalysisNoCalcComReqDto = new ImplementCurrentCycleTypeAnalysisNoCalcComReqDto();
        if (reqDto != null) {
            implementCurrentCycleTypeAnalysisNoCalcComReqDto.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1028747_1_40802
            implementCurrentCycleTypeAnalysisNoCalcComReqDto.setCycleId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:1028748_1_40802
            implementCurrentCycleTypeAnalysisNoCalcComReqDto.setCurrentCycleType(reqDto.getCurrentCycleType());//SimpleFieldAssign//sourceId:914886_1_40802
            implementCurrentCycleTypeAnalysisNoCalcComReqDto.setLastCycleType(reqDto.getLastCycleType());//SimpleFieldAssign//sourceId:914887_1_40802
            implementCurrentCycleTypeAnalysisNoCalcComReqDto.setIsFatherCycle(reqDto.getIsFatherCycle());//SimpleFieldAssign//sourceId:1006774_1_40802
            implementCurrentCycleTypeAnalysisNoCalcComReqDto.setIsMetaphase(reqDto.getIsMetaphase());//SimpleFieldAssign//sourceId:1006776_1_40802
            implementCurrentCycleTypeAnalysisNoCalcComReqDto.setIsSubCycle(reqDto.getIsSubCycle());//SimpleFieldAssign//sourceId:1006775_1_40802
            implementCurrentCycleTypeAnalysisNoCalcComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1028749_1_40802
        }

        /*D3-执行标准数据计算周期模型分析(公共)[6546]   */
        Assert.isNull(implementCurrentCycleTypeAnalysisNoCalcComReqDto.getEvaObjTargetCycleId(), "D3-执行回写是否自动汇报(公共)-D3-执行标准数据计算周期模型分析(公共)-被评对象目标周期ID不能为空", false);
        Assert.isNull(implementCurrentCycleTypeAnalysisNoCalcComReqDto.getCycleId(), "D3-执行回写是否自动汇报(公共)-D3-执行标准数据计算周期模型分析(公共)-周期ID不能为空", false);
        Assert.isNull(implementCurrentCycleTypeAnalysisNoCalcComReqDto.getCurrentCycleType(), "D3-执行回写是否自动汇报(公共)-D3-执行标准数据计算周期模型分析(公共)-当前周期类型不能为空", false);
        Assert.isNull(implementCurrentCycleTypeAnalysisNoCalcComReqDto.getIsFatherCycle(), "D3-执行回写是否自动汇报(公共)-D3-执行标准数据计算周期模型分析(公共)-是否父周期不能为空", false);
        Assert.isNull(implementCurrentCycleTypeAnalysisNoCalcComReqDto.getIsMetaphase(), "D3-执行回写是否自动汇报(公共)-D3-执行标准数据计算周期模型分析(公共)-是否中期不能为空", false);
        Assert.isNull(implementCurrentCycleTypeAnalysisNoCalcComReqDto.getIsSubCycle(), "D3-执行回写是否自动汇报(公共)-D3-执行标准数据计算周期模型分析(公共)-是否子周期不能为空", false);
        Assert.isNull(implementCurrentCycleTypeAnalysisNoCalcComReqDto.getEvaluationTemplateId(), "D3-执行回写是否自动汇报(公共)-D3-执行标准数据计算周期模型分析(公共)-冗余评价模板ID不能为空", false);
        implementCurrentCycleTypeAnalysisNoCalcComRespDto = implementCurrentCycleTypeAnalysisNoCalcCom(implementCurrentCycleTypeAnalysisNoCalcComReqDto)/*vcase invoke 同服务,同domain*/;


//virtualUsage D4-进度值人工汇报条件模型(公共)  40744
        ImplementProgressValueManualFormAnalysisComRespDto implementProgressValueManualFormAnalysisComRespDto = null;
        if (implementCurrentCycleTypeAnalysisNoCalcComRespDto != null) {
            ImplementProgressValueManualFormAnalysisComReqDto implementProgressValueManualFormAnalysisComReqDto = new ImplementProgressValueManualFormAnalysisComReqDto();
            if (reqDto != null) {
                implementProgressValueManualFormAnalysisComReqDto.setSchemeDataPara(reqDto.getSchemeDataPara());//SimpleFieldAssign//sourceId:913228_1_40744
                implementProgressValueManualFormAnalysisComReqDto.setReportType(reqDto.getReportType());//SimpleFieldAssign//sourceId:913230_1_40744
                implementProgressValueManualFormAnalysisComReqDto.setEvaObjTypeCode(reqDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:913229_1_40744
                implementProgressValueManualFormAnalysisComReqDto.setTargetCycleContentTypeCode(reqDto.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:913224_1_40744
                implementProgressValueManualFormAnalysisComReqDto.setTargetValueType(reqDto.getTargetValueType());//SimpleFieldAssign//sourceId:913225_1_40744
                implementProgressValueManualFormAnalysisComReqDto.setIsLastObjective(reqDto.getIsLastObjective());//SimpleFieldAssign//sourceId:913223_1_40744
                implementProgressValueManualFormAnalysisComReqDto.setCalculateDataSource(reqDto.getCalculateDataSource());//SimpleFieldAssign//sourceId:913226_1_40744
            }
            if (implementCurrentCycleTypeAnalysisNoCalcComRespDto != null) {
                implementProgressValueManualFormAnalysisComReqDto.setStandardDataCalcCycleModel(implementCurrentCycleTypeAnalysisNoCalcComRespDto.getStandardDataCalcCycleModel());//SimpleFieldAssign//sourceId:913233_1_40744
            }

            /*D4-进度值人工汇报条件模型(公共)[6397]   */
            Assert.isNull(implementProgressValueManualFormAnalysisComReqDto.getSchemeDataPara(), "D3-执行回写是否自动汇报(公共)-D4-进度值人工汇报条件模型(公共)-评价模板商业参数不能为空", false);
            Assert.isNull(implementProgressValueManualFormAnalysisComReqDto.getReportType(), "D3-执行回写是否自动汇报(公共)-D4-进度值人工汇报条件模型(公共)-汇报类型不能为空", false);
            Assert.isNull(implementProgressValueManualFormAnalysisComReqDto.getEvaObjTypeCode(), "D3-执行回写是否自动汇报(公共)-D4-进度值人工汇报条件模型(公共)-被评对象类型编码不能为空", false);
            Assert.isNull(implementProgressValueManualFormAnalysisComReqDto.getTargetCycleContentTypeCode(), "D3-执行回写是否自动汇报(公共)-D4-进度值人工汇报条件模型(公共)-关联目标内容类型编码不能为空", false);
            Assert.isNull(implementProgressValueManualFormAnalysisComReqDto.getStandardDataCalcCycleModel(), "D3-执行回写是否自动汇报(公共)-D4-进度值人工汇报条件模型(公共)-标准数据计算周期模型不能为空", false);
            implementProgressValueManualFormAnalysisComRespDto = fwCalcGridCalculateClient.implementProgressValueManualFormAnalysisCom(implementProgressValueManualFormAnalysisComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


        }
//virtualUsage D4-实际值人工汇报条件模型(公共)  40745
        ImplementActualValueManualFormAnalysisComRespDto implementActualValueManualFormAnalysisComRespDto = null;
        if (implementCurrentCycleTypeAnalysisNoCalcComRespDto != null) {
            ImplementActualValueManualFormAnalysisComReqDto implementActualValueManualFormAnalysisComReqDto = new ImplementActualValueManualFormAnalysisComReqDto();
            if (reqDto != null) {
                implementActualValueManualFormAnalysisComReqDto.setEvaObjTypeCode(reqDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:913235_1_40745
                implementActualValueManualFormAnalysisComReqDto.setTargetCycleContentTypeCode(reqDto.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:913236_1_40745
                implementActualValueManualFormAnalysisComReqDto.setIsLastObjective(reqDto.getIsLastObjective());//SimpleFieldAssign//sourceId:913242_1_40745
                implementActualValueManualFormAnalysisComReqDto.setTargetValueType(reqDto.getTargetValueType());//SimpleFieldAssign//sourceId:913237_1_40745
                implementActualValueManualFormAnalysisComReqDto.setQuantityObjectiveNoValue(reqDto.getQuantityObjectiveNoValue());//SimpleFieldAssign//sourceId:913243_1_40745
                implementActualValueManualFormAnalysisComReqDto.setCalculateDataSource(reqDto.getCalculateDataSource());//SimpleFieldAssign//sourceId:913238_1_40745
            }
            if (implementCurrentCycleTypeAnalysisNoCalcComRespDto != null) {
                implementActualValueManualFormAnalysisComReqDto.setStandardDataCalcCycleModel(implementCurrentCycleTypeAnalysisNoCalcComRespDto.getStandardDataCalcCycleModel());//SimpleFieldAssign//sourceId:913239_1_40745
            }

            /*D4-实际值人工汇报条件模型(公共)[6416]   */
            Assert.isNull(implementActualValueManualFormAnalysisComReqDto.getEvaObjTypeCode(), "D3-执行回写是否自动汇报(公共)-D4-实际值人工汇报条件模型(公共)-被评对象类型编码不能为空", false);
            Assert.isNull(implementActualValueManualFormAnalysisComReqDto.getTargetCycleContentTypeCode(), "D3-执行回写是否自动汇报(公共)-D4-实际值人工汇报条件模型(公共)-关联目标内容类型编码不能为空", false);
            Assert.isNull(implementActualValueManualFormAnalysisComReqDto.getStandardDataCalcCycleModel(), "D3-执行回写是否自动汇报(公共)-D4-实际值人工汇报条件模型(公共)-标准数据计算周期模型不能为空", false);
            implementActualValueManualFormAnalysisComRespDto = fwCalcGridCalculateClient.implementActualValueManualFormAnalysisCom(implementActualValueManualFormAnalysisComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


        }
        if ((reqDto != null && reqDto.getReportType() != null && reqDto.getReportType().equals("AUTO_REPORT")) || (reqDto != null && reqDto.getTargetCycleContentTypeCode() != null && reqDto.getTargetCycleContentTypeCode().equals("TARGET_CATEGORY") && reqDto != null && reqDto.getConstTaskIsOpenReport() != null && reqDto.getConstTaskIsOpenReport().equals("TRUE") && reqDto != null && reqDto.getConstIsOpenAtuoReport() != null && reqDto.getConstIsOpenAtuoReport().equals("TRUE"))) {
            //if(D3-执行回写是否自动汇报(公共).汇报类型 等于 全自动汇报 or (D3-执行回写是否自动汇报(公共).关联目标内容类型编码 等于 目标分类 and D3-执行回写是否自动汇报(公共).建设任务是否开启汇报 等于 是 and D3-执行回写是否自动汇报(公共).建设任务是否自动汇报 等于 是))  44832

            if ((reqDto != null && reqDto.getSchemeDataPara() != null && reqDto.getSchemeDataPara().equals("DOC_TYPE"))) {
                //if(D3-执行回写是否自动汇报(公共).评价模板数据参数 等于 资料型)  44837

                if ((implementActualValueManualFormAnalysisComRespDto != null && implementActualValueManualFormAnalysisComRespDto.getActualValueCalcFormula() == null)) {
                    //if(D4-分析实际值是否人工汇报.实际值计算公式 值等于空 )  44846

                    boolean bOOLEAN;
                    OmsTask omsTask = new OmsTask();
                    omsTask.setIsAutoReport("TRUE");//sourceId:913567_1_44847
                    if (reqDto != null) {
                        omsTask.setTaskId(reqDto.getTaskId());//SimpleFieldAssign//sourceId:913566_1_44847
                    }

                    /*3-7-01修改任务（修改为自动提交汇报）[2706]   */
                    Assert.isNull(omsTask.getTaskId(), "D3-执行回写是否自动汇报(公共)-3-7-01修改任务（修改为自动提交汇报）-任务ID不能为空", false);
                    Assert.isNull(omsTask.getIsAutoReport(), "D3-执行回写是否自动汇报(公共)-3-7-01修改任务（修改为自动提交汇报）-是否自动汇报不能为空", false);
                    bOOLEAN = mOmsTaskService.updateTask(omsTask)/*vcase invoke 本地 method 方法调用;*/;


                    if ((reqDto != null && reqDto.getTargetValueType() != null && reqDto.getTargetValueType().equals("SUBJECTIVE_QUALITATIVE") || reqDto != null && reqDto.getQuantityObjectiveNoValue() != null && reqDto.getQuantityObjectiveNoValue().equals("TRUE"))) {
                        //if((D3-执行回写是否自动汇报(公共).冗余指标业务类型 等于 主观定性 or D3-执行回写是否自动汇报(公共).数量型指标当无实际值标记 等于 是))  49723

                        boolean bOOLEAN_1;
                        OmsTask omsTask_1 = new OmsTask();
                        omsTask_1.setIsAutoReport("FALSE");//sourceId:1163528_1_49724
                        if (reqDto != null) {
                            omsTask_1.setTaskId(reqDto.getTaskId());//SimpleFieldAssign//sourceId:1163527_1_49724
                        }

                        /*3-7-01修改任务（修改为非自动提交汇报）[2706]   */
                        Assert.isNull(omsTask_1.getTaskId(), "D3-执行回写是否自动汇报(公共)-3-7-01修改任务（修改为非自动提交汇报）-任务ID不能为空", false);
                        Assert.isNull(omsTask_1.getIsAutoReport(), "D3-执行回写是否自动汇报(公共)-3-7-01修改任务（修改为非自动提交汇报）-是否自动汇报不能为空", false);
                        bOOLEAN_1 = mOmsTaskService.updateTask(omsTask_1)/*vcase invoke 本地 method 方法调用;*/;


                    }
                }
            } else if ((reqDto != null && reqDto.getSchemeDataPara() != null && reqDto.getSchemeDataPara().equals("PROCESS_TYPE"))) {
                //elseif(D3-执行回写是否自动汇报(公共).评价模板数据参数 等于 进度型)  44842

                if ((implementProgressValueManualFormAnalysisComRespDto != null && implementProgressValueManualFormAnalysisComRespDto.getProgressValueCalcFormula() == null && implementActualValueManualFormAnalysisComRespDto != null && implementActualValueManualFormAnalysisComRespDto.getActualValueCalcFormula() == null)) {
                    //if((D4-分析进度值是否人工汇报.进度值计算公式 值等于空  and D4-分析实际值是否人工汇报.实际值计算公式 值等于空 ))  44849

                    boolean bOOLEAN_2;
                    OmsTask omsTask_2 = new OmsTask();
                    omsTask_2.setIsAutoReport("TRUE");//sourceId:913567_1_44850
                    if (reqDto != null) {
                        omsTask_2.setTaskId(reqDto.getTaskId());//SimpleFieldAssign//sourceId:913566_1_44850
                    }

                    /*3-7-01修改任务（修改为自动提交汇报）[2706]   */
                    Assert.isNull(omsTask_2.getTaskId(), "D3-执行回写是否自动汇报(公共)-3-7-01修改任务（修改为自动提交汇报）-任务ID不能为空", false);
                    Assert.isNull(omsTask_2.getIsAutoReport(), "D3-执行回写是否自动汇报(公共)-3-7-01修改任务（修改为自动提交汇报）-是否自动汇报不能为空", false);
                    bOOLEAN_2 = mOmsTaskService.updateTask(omsTask_2)/*vcase invoke 本地 method 方法调用;*/;


                    if ((reqDto != null && reqDto.getTargetValueType() != null && reqDto.getTargetValueType().equals("SUBJECTIVE_QUALITATIVE") && reqDto != null && reqDto.getNoPracticalValueObjIsProgReport() != null && reqDto.getNoPracticalValueObjIsProgReport().equals("TRUE") && reqDto != null && reqDto.getIsOkrPlanScene() != null && reqDto.getIsOkrPlanScene().equals("NO_OKR_PLAN_SCENE") && reqDto != null && reqDto.getIndicatorKind() != null && reqDto.getIndicatorKind().equals("OBJECTIVES") && reqDto != null && reqDto.getIsLastObjective() != null && reqDto.getIsLastObjective().equals("TRUE"))) {
                        //if((D3-执行回写是否自动汇报(公共).冗余指标业务类型 等于 主观定性 and D3-执行回写是否自动汇报(公共).无实际值指标是否开启进度汇报 等于 是 and D3-执行回写是否自动汇报(公共).冗余开启OKR场景 等于 无OKR场景 and D3-执行回写是否自动汇报(公共).OKR目标属性 等于 目标O and D3-执行回写是否自动汇报(公共).是否末级指标 等于 是))  49727

                        boolean bOOLEAN_3;
                        OmsTask omsTask_3 = new OmsTask();
                        omsTask_3.setIsAutoReport("FALSE");//sourceId:1163528_1_49728
                        if (reqDto != null) {
                            omsTask_3.setTaskId(reqDto.getTaskId());//SimpleFieldAssign//sourceId:1163527_1_49728
                        }

                        /*3-7-01修改任务（修改为非自动提交汇报）[2706]   */
                        Assert.isNull(omsTask_3.getTaskId(), "D3-执行回写是否自动汇报(公共)-3-7-01修改任务（修改为非自动提交汇报）-任务ID不能为空", false);
                        Assert.isNull(omsTask_3.getIsAutoReport(), "D3-执行回写是否自动汇报(公共)-3-7-01修改任务（修改为非自动提交汇报）-是否自动汇报不能为空", false);
                        bOOLEAN_3 = mOmsTaskService.updateTask(omsTask_3)/*vcase invoke 本地 method 方法调用;*/;


                    }
                }
            } else if ((reqDto != null && reqDto.getSchemeDataPara() != null && reqDto.getSchemeDataPara().equals("REACH_TYPE"))) {
                //elseif(D3-执行回写是否自动汇报(公共).评价模板数据参数 等于 达成度型)  44843

                if ((implementActualValueManualFormAnalysisComRespDto != null && implementActualValueManualFormAnalysisComRespDto.getActualValueCalcFormula() == null && reqDto != null && reqDto.getIsSubjectiveScoring() != null && reqDto.getIsSubjectiveScoring().equals("FALSE"))) {
                    //if((D4-分析实际值是否人工汇报.实际值计算公式 值等于空  and D3-执行回写是否自动汇报(公共).是否开启主观评分 等于 否))  44852

                    boolean bOOLEAN_4;
                    OmsTask omsTask_4 = new OmsTask();
                    omsTask_4.setIsAutoReport("TRUE");//sourceId:913567_1_44874
                    if (reqDto != null) {
                        omsTask_4.setTaskId(reqDto.getTaskId());//SimpleFieldAssign//sourceId:913566_1_44874
                    }

                    /*3-7-01修改任务（修改为自动提交汇报）[2706]   */
                    Assert.isNull(omsTask_4.getTaskId(), "D3-执行回写是否自动汇报(公共)-3-7-01修改任务（修改为自动提交汇报）-任务ID不能为空", false);
                    Assert.isNull(omsTask_4.getIsAutoReport(), "D3-执行回写是否自动汇报(公共)-3-7-01修改任务（修改为自动提交汇报）-是否自动汇报不能为空", false);
                    bOOLEAN_4 = mOmsTaskService.updateTask(omsTask_4)/*vcase invoke 本地 method 方法调用;*/;


                    if ((reqDto != null && reqDto.getTargetValueType() != null && reqDto.getTargetValueType().equals("SUBJECTIVE_QUALITATIVE") || reqDto != null && reqDto.getQuantityObjectiveNoValue() != null && reqDto.getQuantityObjectiveNoValue().equals("TRUE"))) {
                        //if((D3-执行回写是否自动汇报(公共).冗余指标业务类型 等于 主观定性 or D3-执行回写是否自动汇报(公共).数量型指标当无实际值标记 等于 是))  49725

                        boolean bOOLEAN_5;
                        OmsTask omsTask_5 = new OmsTask();
                        omsTask_5.setIsAutoReport("FALSE");//sourceId:1163528_1_49726
                        if (reqDto != null) {
                            omsTask_5.setTaskId(reqDto.getTaskId());//SimpleFieldAssign//sourceId:1163527_1_49726
                        }

                        /*3-7-01修改任务（修改为非自动提交汇报）[2706]   */
                        Assert.isNull(omsTask_5.getTaskId(), "D3-执行回写是否自动汇报(公共)-3-7-01修改任务（修改为非自动提交汇报）-任务ID不能为空", false);
                        Assert.isNull(omsTask_5.getIsAutoReport(), "D3-执行回写是否自动汇报(公共)-3-7-01修改任务（修改为非自动提交汇报）-是否自动汇报不能为空", false);
                        bOOLEAN_5 = mOmsTaskService.updateTask(omsTask_5)/*vcase invoke 本地 method 方法调用;*/;


                    }
                }
            } else if ((reqDto != null && reqDto.getSchemeDataPara() != null && reqDto.getSchemeDataPara().equals("MIXED_TYPE"))) {
                //elseif(D3-执行回写是否自动汇报(公共).评价模板数据参数 等于 混合型)  44844

                if ((implementProgressValueManualFormAnalysisComRespDto != null && implementProgressValueManualFormAnalysisComRespDto.getProgressValueCalcFormula() == null && implementActualValueManualFormAnalysisComRespDto != null && implementActualValueManualFormAnalysisComRespDto.getActualValueCalcFormula() == null && reqDto != null && reqDto.getIsSubjectiveScoring() != null && reqDto.getIsSubjectiveScoring().equals("FALSE"))) {
                    //if((D4-分析进度值是否人工汇报.进度值计算公式 值等于空  and D4-分析实际值是否人工汇报.实际值计算公式 值等于空  and D3-执行回写是否自动汇报(公共).是否开启主观评分 等于 否))  44873

                    boolean bOOLEAN_6;
                    OmsTask omsTask_6 = new OmsTask();
                    omsTask_6.setIsAutoReport("TRUE");//sourceId:913567_1_44875
                    if (reqDto != null) {
                        omsTask_6.setTaskId(reqDto.getTaskId());//SimpleFieldAssign//sourceId:913566_1_44875
                    }

                    /*3-7-01修改任务（修改为自动提交汇报）[2706]   */
                    Assert.isNull(omsTask_6.getTaskId(), "D3-执行回写是否自动汇报(公共)-3-7-01修改任务（修改为自动提交汇报）-任务ID不能为空", false);
                    Assert.isNull(omsTask_6.getIsAutoReport(), "D3-执行回写是否自动汇报(公共)-3-7-01修改任务（修改为自动提交汇报）-是否自动汇报不能为空", false);
                    bOOLEAN_6 = mOmsTaskService.updateTask(omsTask_6)/*vcase invoke 本地 method 方法调用;*/;


                    if ((reqDto != null && reqDto.getTargetValueType() != null && reqDto.getTargetValueType().equals("SUBJECTIVE_QUALITATIVE") && reqDto != null && reqDto.getNoPracticalValueObjIsProgReport() != null && reqDto.getNoPracticalValueObjIsProgReport().equals("TRUE") && reqDto != null && reqDto.getIsOkrPlanScene() != null && reqDto.getIsOkrPlanScene().equals("NO_OKR_PLAN_SCENE") && reqDto != null && reqDto.getIndicatorKind() != null && reqDto.getIndicatorKind().equals("OBJECTIVES") && reqDto != null && reqDto.getIsLastObjective() != null && reqDto.getIsLastObjective().equals("TRUE"))) {
                        //if((D3-执行回写是否自动汇报(公共).冗余指标业务类型 等于 主观定性 and D3-执行回写是否自动汇报(公共).无实际值指标是否开启进度汇报 等于 是 and D3-执行回写是否自动汇报(公共).冗余开启OKR场景 等于 无OKR场景 and D3-执行回写是否自动汇报(公共).OKR目标属性 等于 目标O and D3-执行回写是否自动汇报(公共).是否末级指标 等于 是))  49729

                        boolean bOOLEAN_7;
                        OmsTask omsTask_7 = new OmsTask();
                        omsTask_7.setIsAutoReport("FALSE");//sourceId:1163528_1_49730
                        if (reqDto != null) {
                            omsTask_7.setTaskId(reqDto.getTaskId());//SimpleFieldAssign//sourceId:1163527_1_49730
                        }

                        /*3-7-01修改任务（修改为非自动提交汇报）[2706]   */
                        Assert.isNull(omsTask_7.getTaskId(), "D3-执行回写是否自动汇报(公共)-3-7-01修改任务（修改为非自动提交汇报）-任务ID不能为空", false);
                        Assert.isNull(omsTask_7.getIsAutoReport(), "D3-执行回写是否自动汇报(公共)-3-7-01修改任务（修改为非自动提交汇报）-是否自动汇报不能为空", false);
                        bOOLEAN_7 = mOmsTaskService.updateTask(omsTask_7)/*vcase invoke 本地 method 方法调用;*/;


                    }
                }
            }
        }
//virtualUsage D3-执行自动汇报回写周期阶段资料（非人工填报内容）  60332
        ImplementAutoReportWBackCycleStageDataComRespDto implementAutoReportWBackCycleStageDataComRespDto = null;
        ImplementAutoReportWBackCycleStageDataComReqDto implementAutoReportWBackCycleStageDataComReqDto = new ImplementAutoReportWBackCycleStageDataComReqDto();
        if (reqDto != null) {
            implementAutoReportWBackCycleStageDataComReqDto.setTaskId(reqDto.getTaskId());//SimpleFieldAssign//sourceId:1511072_1_60332
        }

        /*D3-执行自动汇报回写周期阶段资料（非人工填报内容）[8363]   */
        Assert.isNull(implementAutoReportWBackCycleStageDataComReqDto.getTaskId(), "D3-执行回写是否自动汇报(公共)-D3-执行自动汇报回写周期阶段资料（非人工填报内容）-任务ID不能为空", false);
        implementAutoReportWBackCycleStageDataComRespDto = taskService.implementAutoReportWBackCycleStageDataCom(implementAutoReportWBackCycleStageDataComReqDto)/*vcase invoke isSameApp*/;


        ImplementWriteBackTaskAutoReportComRespDto retData = new ImplementWriteBackTaskAutoReportComRespDto();


        return retData;
    }

    /**
     * D3-执行标准数据计算周期模型分析(公共)[6546]
     * gen by moon at 6/25/2023, 8:07:52 AM
     */
    @Trace(operationName = "D3-执行标准数据计算周期模型分析(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementCurrentCycleTypeAnalysisNoCalcComRespDto implementCurrentCycleTypeAnalysisNoCalcCom(ImplementCurrentCycleTypeAnalysisNoCalcComReqDto reqDto) {


        CalculateAcceptAboveFieldsRespDto receptionServiceRes_11 = null;
//virtualUsage 末级周期  40774
        //ModelCode: receptionService
        CalculateAcceptAboveFieldsRespDto receptionServiceRes = null;
        CalculateAcceptAboveFieldsReqDto receptionServiceReq = new CalculateAcceptAboveFieldsReqDto();
        receptionServiceReq.setStandardDataCalcCycleModel("LAST_CYCLE");//sourceId:914848_1_40774

        /*末级周期[6495]  用于特殊方法接收上游入参。 */
        Assert.isNull(receptionServiceReq.getStandardDataCalcCycleModel(), "D3-执行标准数据计算周期模型分析(公共)-末级周期-标准数据计算周期模型不能为空", false);
        receptionServiceRes = nbGridCalculate.calculateAcceptAboveFields(receptionServiceReq);


//virtualUsage 中间周期  40775
        //ModelCode: receptionService
        CalculateAcceptAboveFieldsRespDto receptionServiceRes_2 = null;
        CalculateAcceptAboveFieldsReqDto receptionServiceReq_1 = new CalculateAcceptAboveFieldsReqDto();
        receptionServiceReq_1.setStandardDataCalcCycleModel("MID_OF_PROCESS_CYCLE");//sourceId:914849_1_40775

        /*中间周期[6495]  用于特殊方法接收上游入参。 */
        Assert.isNull(receptionServiceReq_1.getStandardDataCalcCycleModel(), "D3-执行标准数据计算周期模型分析(公共)-中间周期-标准数据计算周期模型不能为空", false);
        receptionServiceRes_2 = nbGridCalculate.calculateAcceptAboveFields(receptionServiceReq_1);


//virtualUsage 子周期  40776
        //ModelCode: receptionService
        CalculateAcceptAboveFieldsRespDto receptionServiceRes_4 = null;
        CalculateAcceptAboveFieldsReqDto receptionServiceReq_2 = new CalculateAcceptAboveFieldsReqDto();
        receptionServiceReq_2.setStandardDataCalcCycleModel("SUB_CYCLE");//sourceId:914851_1_40776

        /*子周期[6495]  用于特殊方法接收上游入参。 */
        Assert.isNull(receptionServiceReq_2.getStandardDataCalcCycleModel(), "D3-执行标准数据计算周期模型分析(公共)-子周期-标准数据计算周期模型不能为空", false);
        receptionServiceRes_4 = nbGridCalculate.calculateAcceptAboveFields(receptionServiceReq_2);


//virtualUsage 中期  40777
        //ModelCode: receptionService
        CalculateAcceptAboveFieldsRespDto receptionServiceRes_6 = null;
        CalculateAcceptAboveFieldsReqDto receptionServiceReq_3 = new CalculateAcceptAboveFieldsReqDto();
        receptionServiceReq_3.setStandardDataCalcCycleModel("MID_CYCLE");//sourceId:914852_1_40777

        /*中期[6495]  用于特殊方法接收上游入参。 */
        Assert.isNull(receptionServiceReq_3.getStandardDataCalcCycleModel(), "D3-执行标准数据计算周期模型分析(公共)-中期-标准数据计算周期模型不能为空", false);
        receptionServiceRes_6 = nbGridCalculate.calculateAcceptAboveFields(receptionServiceReq_3);


//virtualUsage 父周期  40779
        //ModelCode: receptionService
        CalculateAcceptAboveFieldsRespDto receptionServiceRes_8 = null;
        CalculateAcceptAboveFieldsReqDto receptionServiceReq_4 = new CalculateAcceptAboveFieldsReqDto();
        receptionServiceReq_4.setStandardDataCalcCycleModel("PARENT_CYCLE");//sourceId:914853_1_40779

        /*父周期[6495]  用于特殊方法接收上游入参。 */
        Assert.isNull(receptionServiceReq_4.getStandardDataCalcCycleModel(), "D3-执行标准数据计算周期模型分析(公共)-父周期-标准数据计算周期模型不能为空", false);
        receptionServiceRes_8 = nbGridCalculate.calculateAcceptAboveFields(receptionServiceReq_4);


        if ((reqDto != null && reqDto.getIsFatherCycle() != null && reqDto.getIsFatherCycle().equals("TRUE") && reqDto != null && reqDto.getIsSubCycle() != null && reqDto.getIsSubCycle().equals("FALSE") && reqDto != null && reqDto.getIsMetaphase() != null && reqDto.getIsMetaphase().equals("FALSE")) || (reqDto != null && reqDto.getIsFatherCycle() != null && reqDto.getIsFatherCycle().equals("TRUE") && reqDto != null && reqDto.getIsMetaphase() != null && reqDto.getIsMetaphase().equals("TRUE") && reqDto != null && reqDto.getIsSubCycle() != null && reqDto.getIsSubCycle().equals("FALSE")) || (reqDto != null && reqDto.getIsFatherCycle() != null && reqDto.getIsFatherCycle().equals("TRUE") && reqDto != null && reqDto.getIsSubCycle() != null && reqDto.getIsSubCycle().equals("TRUE") && reqDto != null && reqDto.getIsMetaphase() != null && reqDto.getIsMetaphase().equals("FALSE")) || (reqDto != null && reqDto.getIsFatherCycle() != null && reqDto.getIsFatherCycle().equals("TRUE") && reqDto != null && reqDto.getIsSubCycle() != null && reqDto.getIsSubCycle().equals("TRUE") && reqDto != null && reqDto.getIsMetaphase() != null && reqDto.getIsMetaphase().equals("TRUE"))) {
            //if((D3-执行标准数据计算周期模型分析(公共).是否父周期 等于 是 and D3-执行标准数据计算周期模型分析(公共).是否子周期 等于 否 and D3-执行标准数据计算周期模型分析(公共).是否中期 等于 否) or (D3-执行标准数据计算周期模型分析(公共).是否父周期 等于 是 and D3-执行标准数据计算周期模型分析(公共).是否中期 等于 是 and D3-执行标准数据计算周期模型分析(公共).是否子周期 等于 否) or (D3-执行标准数据计算周期模型分析(公共).是否父周期 等于 是 and D3-执行标准数据计算周期模型分析(公共).是否子周期 等于 是 and D3-执行标准数据计算周期模型分析(公共).是否中期 等于 否) or (D3-执行标准数据计算周期模型分析(公共).是否父周期 等于 是 and D3-执行标准数据计算周期模型分析(公共).是否子周期 等于 是 and D3-执行标准数据计算周期模型分析(公共).是否中期 等于 是))  44954

            OmsEvaluationObjectTargetCycle omsEvaluationObjectTargetCycle = null;
            QueryEvaObjTargetCycleDetailReq queryEvaObjTargetCycleDetailReq = new QueryEvaObjTargetCycleDetailReq();
            queryEvaObjTargetCycleDetailReq.setIsArchive("FALSE");//sourceId:1028739_1_45015
            if (reqDto != null) {
                queryEvaObjTargetCycleDetailReq.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1028736_1_45015
                queryEvaObjTargetCycleDetailReq.setCycleId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:1028737_1_45015
                queryEvaObjTargetCycleDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1028738_1_45015
            }

            /*3-3-09查被评对象目标周期详情[2313]   */
            Assert.isNull(queryEvaObjTargetCycleDetailReq.getEvaObjTargetCycleId(), "D3-执行标准数据计算周期模型分析(公共)-3-3-09查被评对象目标周期详情-被评对象目标周期ID不能为空", false);
            Assert.isNull(queryEvaObjTargetCycleDetailReq.getCycleId(), "D3-执行标准数据计算周期模型分析(公共)-3-3-09查被评对象目标周期详情-周期ID不能为空", false);
            Assert.isNull(queryEvaObjTargetCycleDetailReq.getEvaluationTemplateId(), "D3-执行标准数据计算周期模型分析(公共)-3-3-09查被评对象目标周期详情-冗余评价模板ID不能为空", false);
            Assert.isNull(queryEvaObjTargetCycleDetailReq.getIsArchive(), "D3-执行标准数据计算周期模型分析(公共)-3-3-09查被评对象目标周期详情-是否存档不能为空", false);
            omsEvaluationObjectTargetCycle = mOmsEvaluationObjectTargetCycleService.queryEvaObjTargetCycleDetail(queryEvaObjTargetCycleDetailReq)/*vcase invoke 本地 method 方法调用;*/;


            if ((omsEvaluationObjectTargetCycle != null)) {
                //if(3-3-09查周期是否目标周期.出参 值不等于空 )  45016

                ImplementStringEfficiencyCheckComRespDto implementStringEfficiencyCheckComRespDto = null;
                if (omsEvaluationObjectTargetCycle != null) {
                    ImplementStringEfficiencyCheckComReqDto implementStringEfficiencyCheckComReqDto = new ImplementStringEfficiencyCheckComReqDto();
                    if (reqDto != null) {
                        implementStringEfficiencyCheckComReqDto.setReferenceString(reqDto.getLastCycleType());//SimpleFieldAssign//sourceId:914253_1_46158
                    }
                    if (omsEvaluationObjectTargetCycle != null) {
                        implementStringEfficiencyCheckComReqDto.setComparisonString(omsEvaluationObjectTargetCycle.getCycleTypeCode());//SimpleFieldAssign//sourceId:914254_1_46158
                    }

                    /*D2-执行字符串对比(公共)[5774]   */
                    Assert.isNull(implementStringEfficiencyCheckComReqDto.getReferenceString(), "D3-执行标准数据计算周期模型分析(公共)-D2-执行字符串对比(公共)-参照字符串不能为空", false);
                    implementStringEfficiencyCheckComRespDto = interfaceModeService.implementStringEfficiencyCheckCom(implementStringEfficiencyCheckComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


                }
                if ((implementStringEfficiencyCheckComRespDto != null && implementStringEfficiencyCheckComRespDto.getStringEfficiencyCheckResult() != null && implementStringEfficiencyCheckComRespDto.getStringEfficiencyCheckResult().equals("TRUE"))) {
                    //if(D2-判断工作周期是否等于末级周期.字符串对比结果 等于 是)  46159

//ModelCode: receptionService
                    CalculateAcceptAboveFieldsRespDto receptionServiceRes_10 = null;
                    CalculateAcceptAboveFieldsReqDto receptionServiceReq_5 = new CalculateAcceptAboveFieldsReqDto();
                    if (receptionServiceRes != null) {
                        receptionServiceReq_5.setStandardDataCalcCycleModel(receptionServiceRes.getStandardDataCalcCycleModel());//SimpleFieldAssign//sourceId:914415_1_46160
                    }

                    /*约定出参：标准数据计算周期模型[6495]  用于特殊方法接收上游入参。 */
                    Assert.isNull(receptionServiceReq_5.getStandardDataCalcCycleModel(), "D3-执行标准数据计算周期模型分析(公共)-约定出参：标准数据计算周期模型-标准数据计算周期模型不能为空", false);
                    receptionServiceRes_10 = nbGridCalculate.calculateAcceptAboveFields(receptionServiceReq_5);


                    receptionServiceRes_11 = receptionServiceRes_10;
                } else if ((implementStringEfficiencyCheckComRespDto != null && implementStringEfficiencyCheckComRespDto.getStringEfficiencyCheckResult() != null && implementStringEfficiencyCheckComRespDto.getStringEfficiencyCheckResult().equals("FALSE"))) {
                    //elseif(D2-判断工作周期是否等于末级周期.字符串对比结果 等于 否)  46161

//ModelCode: receptionService
                    CalculateAcceptAboveFieldsRespDto receptionServiceRes_12 = null;
                    CalculateAcceptAboveFieldsReqDto receptionServiceReq_6 = new CalculateAcceptAboveFieldsReqDto();
                    if (receptionServiceRes_8 != null) {
                        receptionServiceReq_6.setStandardDataCalcCycleModel(receptionServiceRes_8.getStandardDataCalcCycleModel());//SimpleFieldAssign//sourceId:914415_1_46162
                    }

                    /*约定出参：标准数据计算周期模型[6495]  用于特殊方法接收上游入参。 */
                    Assert.isNull(receptionServiceReq_6.getStandardDataCalcCycleModel(), "D3-执行标准数据计算周期模型分析(公共)-约定出参：标准数据计算周期模型-标准数据计算周期模型不能为空", false);
                    receptionServiceRes_12 = nbGridCalculate.calculateAcceptAboveFields(receptionServiceReq_6);


                    receptionServiceRes_11 = receptionServiceRes_12;
                }
            } else if ((omsEvaluationObjectTargetCycle == null)) {
                //elseif(3-3-09查周期是否目标周期.出参 值等于空 )  45018

                ImplementStringEfficiencyCheckComRespDto implementStringEfficiencyCheckComRespDto_2 = null;
                ImplementStringEfficiencyCheckComReqDto implementStringEfficiencyCheckComReqDto_1 = new ImplementStringEfficiencyCheckComReqDto();
                if (reqDto != null) {
                    implementStringEfficiencyCheckComReqDto_1.setReferenceString(reqDto.getCurrentCycleType());//SimpleFieldAssign//sourceId:914253_1_45022
                    implementStringEfficiencyCheckComReqDto_1.setComparisonString(reqDto.getLastCycleType());//SimpleFieldAssign//sourceId:914254_1_45022
                }

                /*D2-执行字符串对比(公共)[5774]   */
                Assert.isNull(implementStringEfficiencyCheckComReqDto_1.getReferenceString(), "D3-执行标准数据计算周期模型分析(公共)-D2-执行字符串对比(公共)-参照字符串不能为空", false);
                implementStringEfficiencyCheckComRespDto_2 = interfaceModeService.implementStringEfficiencyCheckCom(implementStringEfficiencyCheckComReqDto_1).getData()/*vcase invoke 跨dubbo调用;*/;


                if ((implementStringEfficiencyCheckComRespDto_2 != null && implementStringEfficiencyCheckComRespDto_2.getStringEfficiencyCheckResult() != null && implementStringEfficiencyCheckComRespDto_2.getStringEfficiencyCheckResult().equals("TRUE"))) {
                    //if(D2-当前周期类型与末级周期类型对比.字符串对比结果 等于 是)  45023

//ModelCode: receptionService
                    CalculateAcceptAboveFieldsRespDto receptionServiceRes_13 = null;
                    CalculateAcceptAboveFieldsReqDto receptionServiceReq_7 = new CalculateAcceptAboveFieldsReqDto();
                    if (receptionServiceRes != null) {
                        receptionServiceReq_7.setStandardDataCalcCycleModel(receptionServiceRes.getStandardDataCalcCycleModel());//SimpleFieldAssign//sourceId:914415_1_45024
                    }

                    /*约定出参：标准数据计算周期模型[6495]  用于特殊方法接收上游入参。 */
                    Assert.isNull(receptionServiceReq_7.getStandardDataCalcCycleModel(), "D3-执行标准数据计算周期模型分析(公共)-约定出参：标准数据计算周期模型-标准数据计算周期模型不能为空", false);
                    receptionServiceRes_13 = nbGridCalculate.calculateAcceptAboveFields(receptionServiceReq_7);


                    receptionServiceRes_11 = receptionServiceRes_13;
                } else if ((implementStringEfficiencyCheckComRespDto_2 != null && implementStringEfficiencyCheckComRespDto_2.getStringEfficiencyCheckResult() != null && implementStringEfficiencyCheckComRespDto_2.getStringEfficiencyCheckResult().equals("FALSE"))) {
                    //elseif(D2-当前周期类型与末级周期类型对比.字符串对比结果 等于 否)  45025

//ModelCode: receptionService
                    CalculateAcceptAboveFieldsRespDto receptionServiceRes_14 = null;
                    CalculateAcceptAboveFieldsReqDto receptionServiceReq_8 = new CalculateAcceptAboveFieldsReqDto();
                    if (receptionServiceRes_2 != null) {
                        receptionServiceReq_8.setStandardDataCalcCycleModel(receptionServiceRes_2.getStandardDataCalcCycleModel());//SimpleFieldAssign//sourceId:914415_1_45026
                    }

                    /*约定出参：标准数据计算周期模型[6495]  用于特殊方法接收上游入参。 */
                    Assert.isNull(receptionServiceReq_8.getStandardDataCalcCycleModel(), "D3-执行标准数据计算周期模型分析(公共)-约定出参：标准数据计算周期模型-标准数据计算周期模型不能为空", false);
                    receptionServiceRes_14 = nbGridCalculate.calculateAcceptAboveFields(receptionServiceReq_8);


                    receptionServiceRes_11 = receptionServiceRes_14;
                }
            }
        } else if ((reqDto != null && reqDto.getIsMetaphase() != null && reqDto.getIsMetaphase().equals("TRUE") && reqDto != null && reqDto.getIsFatherCycle() != null && reqDto.getIsFatherCycle().equals("FALSE") && reqDto != null && reqDto.getIsSubCycle() != null && reqDto.getIsSubCycle().equals("FALSE"))) {
            //elseif((D3-执行标准数据计算周期模型分析(公共).是否中期 等于 是 and D3-执行标准数据计算周期模型分析(公共).是否父周期 等于 否 and D3-执行标准数据计算周期模型分析(公共).是否子周期 等于 否))  44956

            OmsEvaluationObjectTargetCycle omsEvaluationObjectTargetCycle_2 = null;
            QueryEvaObjTargetCycleDetailReq queryEvaObjTargetCycleDetailReq_1 = new QueryEvaObjTargetCycleDetailReq();
            queryEvaObjTargetCycleDetailReq_1.setIsArchive("FALSE");//sourceId:1028739_1_45019
            if (reqDto != null) {
                queryEvaObjTargetCycleDetailReq_1.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1028736_1_45019
                queryEvaObjTargetCycleDetailReq_1.setCycleId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:1028737_1_45019
                queryEvaObjTargetCycleDetailReq_1.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1028738_1_45019
            }

            /*3-3-09查被评对象目标周期详情[2313]   */
            Assert.isNull(queryEvaObjTargetCycleDetailReq_1.getEvaObjTargetCycleId(), "D3-执行标准数据计算周期模型分析(公共)-3-3-09查被评对象目标周期详情-被评对象目标周期ID不能为空", false);
            Assert.isNull(queryEvaObjTargetCycleDetailReq_1.getCycleId(), "D3-执行标准数据计算周期模型分析(公共)-3-3-09查被评对象目标周期详情-周期ID不能为空", false);
            Assert.isNull(queryEvaObjTargetCycleDetailReq_1.getEvaluationTemplateId(), "D3-执行标准数据计算周期模型分析(公共)-3-3-09查被评对象目标周期详情-冗余评价模板ID不能为空", false);
            Assert.isNull(queryEvaObjTargetCycleDetailReq_1.getIsArchive(), "D3-执行标准数据计算周期模型分析(公共)-3-3-09查被评对象目标周期详情-是否存档不能为空", false);
            omsEvaluationObjectTargetCycle_2 = mOmsEvaluationObjectTargetCycleService.queryEvaObjTargetCycleDetail(queryEvaObjTargetCycleDetailReq_1)/*vcase invoke 本地 method 方法调用;*/;


            if ((omsEvaluationObjectTargetCycle_2 != null)) {
                //if(3-3-09查周期是否目标中期.出参 值不等于空 )  45020

//ModelCode: receptionService
                CalculateAcceptAboveFieldsRespDto receptionServiceRes_15 = null;
                CalculateAcceptAboveFieldsReqDto receptionServiceReq_9 = new CalculateAcceptAboveFieldsReqDto();
                if (receptionServiceRes_6 != null) {
                    receptionServiceReq_9.setStandardDataCalcCycleModel(receptionServiceRes_6.getStandardDataCalcCycleModel());//SimpleFieldAssign//sourceId:914415_1_45021
                }

                /*约定出参：标准数据计算周期模型[6495]  用于特殊方法接收上游入参。 */
                Assert.isNull(receptionServiceReq_9.getStandardDataCalcCycleModel(), "D3-执行标准数据计算周期模型分析(公共)-约定出参：标准数据计算周期模型-标准数据计算周期模型不能为空", false);
                receptionServiceRes_15 = nbGridCalculate.calculateAcceptAboveFields(receptionServiceReq_9);


                receptionServiceRes_11 = receptionServiceRes_15;
            }
        } else if ((reqDto != null && reqDto.getIsSubCycle() != null && reqDto.getIsSubCycle().equals("TRUE") && reqDto != null && reqDto.getIsFatherCycle() != null && reqDto.getIsFatherCycle().equals("FALSE") && reqDto != null && reqDto.getIsMetaphase() != null && reqDto.getIsMetaphase().equals("FALSE"))) {
            //elseif((D3-执行标准数据计算周期模型分析(公共).是否子周期 等于 是 and D3-执行标准数据计算周期模型分析(公共).是否父周期 等于 否 and D3-执行标准数据计算周期模型分析(公共).是否中期 等于 否))  44958

            OmsEvaluationObjectTargetCycle omsEvaluationObjectTargetCycle_3 = null;
            QueryEvaObjTargetCycleDetailReq queryEvaObjTargetCycleDetailReq_2 = new QueryEvaObjTargetCycleDetailReq();
            queryEvaObjTargetCycleDetailReq_2.setIsArchive("FALSE");//sourceId:1028739_1_44960
            if (reqDto != null) {
                queryEvaObjTargetCycleDetailReq_2.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1028736_1_44960
                queryEvaObjTargetCycleDetailReq_2.setCycleId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:1028737_1_44960
                queryEvaObjTargetCycleDetailReq_2.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1028738_1_44960
            }

            /*3-3-09查被评对象目标周期详情[2313]   */
            Assert.isNull(queryEvaObjTargetCycleDetailReq_2.getEvaObjTargetCycleId(), "D3-执行标准数据计算周期模型分析(公共)-3-3-09查被评对象目标周期详情-被评对象目标周期ID不能为空", false);
            Assert.isNull(queryEvaObjTargetCycleDetailReq_2.getCycleId(), "D3-执行标准数据计算周期模型分析(公共)-3-3-09查被评对象目标周期详情-周期ID不能为空", false);
            Assert.isNull(queryEvaObjTargetCycleDetailReq_2.getEvaluationTemplateId(), "D3-执行标准数据计算周期模型分析(公共)-3-3-09查被评对象目标周期详情-冗余评价模板ID不能为空", false);
            Assert.isNull(queryEvaObjTargetCycleDetailReq_2.getIsArchive(), "D3-执行标准数据计算周期模型分析(公共)-3-3-09查被评对象目标周期详情-是否存档不能为空", false);
            omsEvaluationObjectTargetCycle_3 = mOmsEvaluationObjectTargetCycleService.queryEvaObjTargetCycleDetail(queryEvaObjTargetCycleDetailReq_2)/*vcase invoke 本地 method 方法调用;*/;


            if ((omsEvaluationObjectTargetCycle_3 != null)) {
                //if(3-3-09查周期是否目标周期.出参 值不等于空 )  44961

                ImplementStringEfficiencyCheckComRespDto implementStringEfficiencyCheckComRespDto_3 = null;
                if (omsEvaluationObjectTargetCycle_3 != null) {
                    ImplementStringEfficiencyCheckComReqDto implementStringEfficiencyCheckComReqDto_2 = new ImplementStringEfficiencyCheckComReqDto();
                    if (omsEvaluationObjectTargetCycle_3 != null) {
                        implementStringEfficiencyCheckComReqDto_2.setReferenceString(omsEvaluationObjectTargetCycle_3.getCycleTypeCode());//SimpleFieldAssign//sourceId:914253_1_46163
                    }
                    if (reqDto != null) {
                        implementStringEfficiencyCheckComReqDto_2.setComparisonString(reqDto.getLastCycleType());//SimpleFieldAssign//sourceId:914254_1_46163
                    }

                    /*D2-执行字符串对比(公共)[5774]   */
                    Assert.isNull(implementStringEfficiencyCheckComReqDto_2.getReferenceString(), "D3-执行标准数据计算周期模型分析(公共)-D2-执行字符串对比(公共)-参照字符串不能为空", false);
                    implementStringEfficiencyCheckComRespDto_3 = interfaceModeService.implementStringEfficiencyCheckCom(implementStringEfficiencyCheckComReqDto_2).getData()/*vcase invoke 跨dubbo调用;*/;


                }
                if ((implementStringEfficiencyCheckComRespDto_3 != null && implementStringEfficiencyCheckComRespDto_3.getStringEfficiencyCheckResult() != null && implementStringEfficiencyCheckComRespDto_3.getStringEfficiencyCheckResult().equals("FALSE"))) {
                    //if(D2-子周期类型与末级周期类型对比.字符串对比结果 等于 否)  44969

//ModelCode: receptionService
                    CalculateAcceptAboveFieldsRespDto receptionServiceRes_16 = null;
                    CalculateAcceptAboveFieldsReqDto receptionServiceReq_10 = new CalculateAcceptAboveFieldsReqDto();
                    if (receptionServiceRes_4 != null) {
                        receptionServiceReq_10.setStandardDataCalcCycleModel(receptionServiceRes_4.getStandardDataCalcCycleModel());//SimpleFieldAssign//sourceId:914415_1_44970
                    }

                    /*约定出参：标准数据计算周期模型[6495]  用于特殊方法接收上游入参。 */
                    Assert.isNull(receptionServiceReq_10.getStandardDataCalcCycleModel(), "D3-执行标准数据计算周期模型分析(公共)-约定出参：标准数据计算周期模型-标准数据计算周期模型不能为空", false);
                    receptionServiceRes_16 = nbGridCalculate.calculateAcceptAboveFields(receptionServiceReq_10);


                    receptionServiceRes_11 = receptionServiceRes_16;
                } else if ((implementStringEfficiencyCheckComRespDto_3 != null && implementStringEfficiencyCheckComRespDto_3.getStringEfficiencyCheckResult() != null && implementStringEfficiencyCheckComRespDto_3.getStringEfficiencyCheckResult().equals("TRUE"))) {
                    //elseif(D2-子周期类型与末级周期类型对比.字符串对比结果 等于 是)  44971

//ModelCode: receptionService
                    CalculateAcceptAboveFieldsRespDto receptionServiceRes_17 = null;
                    CalculateAcceptAboveFieldsReqDto receptionServiceReq_11 = new CalculateAcceptAboveFieldsReqDto();
                    if (receptionServiceRes != null) {
                        receptionServiceReq_11.setStandardDataCalcCycleModel(receptionServiceRes.getStandardDataCalcCycleModel());//SimpleFieldAssign//sourceId:914415_1_44972
                    }

                    /*约定出参：标准数据计算周期模型[6495]  用于特殊方法接收上游入参。 */
                    Assert.isNull(receptionServiceReq_11.getStandardDataCalcCycleModel(), "D3-执行标准数据计算周期模型分析(公共)-约定出参：标准数据计算周期模型-标准数据计算周期模型不能为空", false);
                    receptionServiceRes_17 = nbGridCalculate.calculateAcceptAboveFields(receptionServiceReq_11);


                    receptionServiceRes_11 = receptionServiceRes_17;
                }
            } else if ((omsEvaluationObjectTargetCycle_3 == null)) {
                //elseif(3-3-09查周期是否目标周期.出参 值等于空 )  44963

                ImplementStringEfficiencyCheckComRespDto implementStringEfficiencyCheckComRespDto_4 = null;
                ImplementStringEfficiencyCheckComReqDto implementStringEfficiencyCheckComReqDto_3 = new ImplementStringEfficiencyCheckComReqDto();
                if (reqDto != null) {
                    implementStringEfficiencyCheckComReqDto_3.setReferenceString(reqDto.getCurrentCycleType());//SimpleFieldAssign//sourceId:914253_1_44964
                    implementStringEfficiencyCheckComReqDto_3.setComparisonString(reqDto.getLastCycleType());//SimpleFieldAssign//sourceId:914254_1_44964
                }

                /*D2-执行字符串对比(公共)[5774]   */
                Assert.isNull(implementStringEfficiencyCheckComReqDto_3.getReferenceString(), "D3-执行标准数据计算周期模型分析(公共)-D2-执行字符串对比(公共)-参照字符串不能为空", false);
                implementStringEfficiencyCheckComRespDto_4 = interfaceModeService.implementStringEfficiencyCheckCom(implementStringEfficiencyCheckComReqDto_3).getData()/*vcase invoke 跨dubbo调用;*/;


                if ((implementStringEfficiencyCheckComRespDto_4 != null && implementStringEfficiencyCheckComRespDto_4.getStringEfficiencyCheckResult() != null && implementStringEfficiencyCheckComRespDto_4.getStringEfficiencyCheckResult().equals("TRUE"))) {
                    //if(D2-当前周期类型与末级周期类型对比.字符串对比结果 等于 是)  44965

//ModelCode: receptionService
                    CalculateAcceptAboveFieldsRespDto receptionServiceRes_18 = null;
                    CalculateAcceptAboveFieldsReqDto receptionServiceReq_12 = new CalculateAcceptAboveFieldsReqDto();
                    if (receptionServiceRes != null) {
                        receptionServiceReq_12.setStandardDataCalcCycleModel(receptionServiceRes.getStandardDataCalcCycleModel());//SimpleFieldAssign//sourceId:914415_1_44966
                    }

                    /*约定出参：标准数据计算周期模型[6495]  用于特殊方法接收上游入参。 */
                    Assert.isNull(receptionServiceReq_12.getStandardDataCalcCycleModel(), "D3-执行标准数据计算周期模型分析(公共)-约定出参：标准数据计算周期模型-标准数据计算周期模型不能为空", false);
                    receptionServiceRes_18 = nbGridCalculate.calculateAcceptAboveFields(receptionServiceReq_12);


                    receptionServiceRes_11 = receptionServiceRes_18;
                } else if ((implementStringEfficiencyCheckComRespDto_4 != null && implementStringEfficiencyCheckComRespDto_4.getStringEfficiencyCheckResult() != null && implementStringEfficiencyCheckComRespDto_4.getStringEfficiencyCheckResult().equals("FALSE"))) {
                    //elseif(D2-当前周期类型与末级周期类型对比.字符串对比结果 等于 否)  44967

//ModelCode: receptionService
                    CalculateAcceptAboveFieldsRespDto receptionServiceRes_19 = null;
                    CalculateAcceptAboveFieldsReqDto receptionServiceReq_13 = new CalculateAcceptAboveFieldsReqDto();
                    if (receptionServiceRes_2 != null) {
                        receptionServiceReq_13.setStandardDataCalcCycleModel(receptionServiceRes_2.getStandardDataCalcCycleModel());//SimpleFieldAssign//sourceId:914415_1_44968
                    }

                    /*约定出参：标准数据计算周期模型[6495]  用于特殊方法接收上游入参。 */
                    Assert.isNull(receptionServiceReq_13.getStandardDataCalcCycleModel(), "D3-执行标准数据计算周期模型分析(公共)-约定出参：标准数据计算周期模型-标准数据计算周期模型不能为空", false);
                    receptionServiceRes_19 = nbGridCalculate.calculateAcceptAboveFields(receptionServiceReq_13);


                    receptionServiceRes_11 = receptionServiceRes_19;
                }
            }
        }
        ImplementCurrentCycleTypeAnalysisNoCalcComRespDto retData = new ImplementCurrentCycleTypeAnalysisNoCalcComRespDto();
        if (receptionServiceRes_11 != null) {
            retData.setStandardDataCalcCycleModel(receptionServiceRes_11.getStandardDataCalcCycleModel());//SimpleFieldAssign//sourceId:914879_1
        }


        return retData;
    }


    /**
     * D3-执行重新计算标准数据(公共)[6521]
     * gen by moon at 5/10/2023, 1:31:59 AM
     */
    @Trace(operationName = "D3-执行重新计算标准数据(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementRecalcStandardDataComRespDto implementRecalcStandardDataCom(ImplementRecalcStandardDataComReqDto reqDto) {

//
//      //virtualUsage D4-1查询标准数据列表(公共)  40510
//      QueryStandardDataListComRespDto queryStandardDataListComRespDto = null;
//    QueryStandardDataListComReqDto queryStandardDataListComReqDto=new QueryStandardDataListComReqDto();
//  queryStandardDataListComReqDto.setIsNewData("TRUE");//sourceId:904101_1_40510
//queryStandardDataListComReqDto.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:904104_1_40510
//if(reqDto!=null){
//      queryStandardDataListComReqDto.setEntityId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:904103_1_40510
//queryStandardDataListComReqDto.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:904105_1_40510
//    }
//
//    /*D4-1查询标准数据列表(公共)[4696]   */
//    Assert.isNull(queryStandardDataListComReqDto.getEntityId(),"D3-执行重新计算标准数据(公共)-D4-1查询标准数据列表(公共)-归属内容表主键ID不能为空",false);
//Assert.isNull(queryStandardDataListComReqDto.getIsNewData(),"D3-执行重新计算标准数据(公共)-D4-1查询标准数据列表(公共)-是否归属周期最新数据不能为空",false);
//Assert.isNull(queryStandardDataListComReqDto.getSubjectLifeCycle(),"D3-执行重新计算标准数据(公共)-D4-1查询标准数据列表(公共)-主体生命周期不能为空",false);
//Assert.isNull(queryStandardDataListComReqDto.getThemeContentId(),"D3-执行重新计算标准数据(公共)-D4-1查询标准数据列表(公共)-主题内容ID不能为空",false);
//      queryStandardDataListComRespDto = fwCalcStandardDataClient.queryStandardDataListCom(queryStandardDataListComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;
//
//
//
//if((queryStandardDataListComRespDto!= null&&  queryStandardDataListComRespDto.getStandardDataList() !=null && queryStandardDataListComRespDto.getStandardDataList().size()>0)) {
//        //if(D4-1查询标准数据列表(公共).标准数据列表数据集条数 大于 0)  40512
//
////ModelCode: circulationCollections
//        for (StandardDataDto circulationCollectionsRes: queryStandardDataListComRespDto.getStandardDataList()){
//
//OmsExecuteCycleStage omsExecuteCycleStage = null;
//    QueryExecuteCycleStageDetailReq queryExecuteCycleStageDetailReq=new QueryExecuteCycleStageDetailReq();
//  queryExecuteCycleStageDetailReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:910411_1_40678
//if(circulationCollectionsRes!=null){
////      queryExecuteCycleStageDetailReq.setCycleId(circulationCollectionsRes.getCycleId());//SimpleFieldAssign//sourceId:910409_1_40678
//    }
//if(reqDto!=null){
//      queryExecuteCycleStageDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:910410_1_40678
//    }
//
//    /*3-3-07查询执行周期阶段详情[2429]   */
//    Assert.isNull(queryExecuteCycleStageDetailReq.getCycleId(),"D3-执行重新计算标准数据(公共)-3-3-07查询执行周期阶段详情-周期ID不能为空",false);
//Assert.isNull(queryExecuteCycleStageDetailReq.getEvaluationTemplateId(),"D3-执行重新计算标准数据(公共)-3-3-07查询执行周期阶段详情-评价模板ID不能为空",false);
//Assert.isNull(queryExecuteCycleStageDetailReq.getSubjectLifeCycle(),"D3-执行重新计算标准数据(公共)-3-3-07查询执行周期阶段详情-主体生命周期不能为空",false);
//      omsExecuteCycleStage = mOmsExecuteCycleStageService.queryExecuteCycleStageDetail(queryExecuteCycleStageDetailReq)/*vcase invoke 本地 method 方法调用;*/;
//
//
//
//QueryPrepareForCalcContentDetailComRespDto queryPrepareForCalcContentDetailComRespDto = null;
//    if(omsExecuteCycleStage !=null){
//          QueryPrepareForCalcContentDetailComReqDto queryPrepareForCalcContentDetailComReqDto=new QueryPrepareForCalcContentDetailComReqDto();
//  if(circulationCollectionsRes!=null){
////      queryPrepareForCalcContentDetailComReqDto.setEvaObjTargetCycleId(circulationCollectionsRes.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:910263_1_40675
//    }
//if(omsExecuteCycleStage!=null){
//      queryPrepareForCalcContentDetailComReqDto.setExecuteCycleStageId(omsExecuteCycleStage.getExecuteCycleStageId());//SimpleFieldAssign//sourceId:910264_1_40675
//    }
//if(reqDto!=null){
//      queryPrepareForCalcContentDetailComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:910265_1_40675
//    }
//
//    /*D4-查询计算准备的内容信息详情(公共)[5993]   */
//    Assert.isNull(queryPrepareForCalcContentDetailComReqDto.getEvaObjTargetCycleId(),"D3-执行重新计算标准数据(公共)-D4-查询计算准备的内容信息详情(公共)-被评对象目标周期ID不能为空",false);
//Assert.isNull(queryPrepareForCalcContentDetailComReqDto.getExecuteCycleStageId(),"D3-执行重新计算标准数据(公共)-D4-查询计算准备的内容信息详情(公共)-执行周期阶段ID不能为空",false);
//Assert.isNull(queryPrepareForCalcContentDetailComReqDto.getEvaluationTemplateId(),"D3-执行重新计算标准数据(公共)-D4-查询计算准备的内容信息详情(公共)-冗余评价模板ID不能为空",false);
//      queryPrepareForCalcContentDetailComRespDto = fwCalcStandardDataClient.queryPrepareForCalcContentDetailCom(queryPrepareForCalcContentDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;
//
//
//
//           }
//if((circulationCollectionsRes!= null&&  circulationCollectionsRes.getDataType() !=null && circulationCollectionsRes.getDataType().equals("ACTUAL_VALUE")||circulationCollectionsRes!= null&&  circulationCollectionsRes.getDataType() !=null && circulationCollectionsRes.getDataType().equals("CHANGE_FROM_LAST_TARGET")||circulationCollectionsRes!= null&&  circulationCollectionsRes.getDataType() !=null && circulationCollectionsRes.getDataType().equals("FROM_LAST_TARGET_LIFT_RATIO")||circulationCollectionsRes!= null&&  circulationCollectionsRes.getDataType() !=null && circulationCollectionsRes.getDataType().equals("COUNT_ACTUAL_VALUE"))) {
//        //if((M3-重新计算全模板内容标准数据【循环开始】.数据类型编码 等于 实际值 or M3-重新计算全模板内容标准数据【循环开始】.数据类型编码 等于 较上次目标变化值 or M3-重新计算全模板内容标准数据【循环开始】.数据类型编码 等于 较上次目标增降幅 or M3-重新计算全模板内容标准数据【循环开始】.数据类型编码 等于 计算实际值))  40669
//
//ImplementActualValueCalcFormulaAnalysisComRespDto implementActualValueCalcFormulaAnalysisComRespDto = null;
//    if(queryPrepareForCalcContentDetailComRespDto !=null){
//          ImplementActualValueCalcFormulaAnalysisComReqDto implementActualValueCalcFormulaAnalysisComReqDto=new ImplementActualValueCalcFormulaAnalysisComReqDto();
//  if(reqDto!=null){
//      implementActualValueCalcFormulaAnalysisComReqDto.setSchemeDataPara(reqDto.getSchemeDataPara());//SimpleFieldAssign//sourceId:910192_1_40670
//implementActualValueCalcFormulaAnalysisComReqDto.setReportType(reqDto.getReportType());//SimpleFieldAssign//sourceId:910193_1_40670
//implementActualValueCalcFormulaAnalysisComReqDto.setIsOkrPlanScene(reqDto.getIsOkrPlanScene());//SimpleFieldAssign//sourceId:910202_1_40670
//implementActualValueCalcFormulaAnalysisComReqDto.setIsOpenSubReportLimit(reqDto.getIsOpenSubReportLimit());//SimpleFieldAssign//sourceId:910206_1_40670
//implementActualValueCalcFormulaAnalysisComReqDto.setLastCycleType(reqDto.getLastCycleType());//SimpleFieldAssign//sourceId:910214_1_40670
//implementActualValueCalcFormulaAnalysisComReqDto.setDecimalPointRules(reqDto.getActualValueDecimalPoint());//SimpleFieldAssign//sourceId:910209_1_40670
//implementActualValueCalcFormulaAnalysisComReqDto.setDecimalDigitsLastRules(reqDto.getDecimalDigitsLastRules());//SimpleFieldAssign//sourceId:910210_1_40670
//implementActualValueCalcFormulaAnalysisComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:910201_1_40670
//    }
//if(circulationCollectionsRes!=null){
//      implementActualValueCalcFormulaAnalysisComReqDto.setEvaObjTargetCycleId(circulationCollectionsRes.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:910200_1_40670
//implementActualValueCalcFormulaAnalysisComReqDto.setCycleId(circulationCollectionsRes.getCycleId());//SimpleFieldAssign//sourceId:910205_1_40670
//implementActualValueCalcFormulaAnalysisComReqDto.setUpdateCycleId(circulationCollectionsRes.getUpdateCycleId());//SimpleFieldAssign//sourceId:910213_1_40670
//implementActualValueCalcFormulaAnalysisComReqDto.setParentSubMidCycleType(circulationCollectionsRes.getParentSubMidCycleType()!=null?String.valueOf(circulationCollectionsRes.getParentSubMidCycleType()):"");//SimpleFieldAssign//sourceId:910207_1_40670
//implementActualValueCalcFormulaAnalysisComReqDto.setUpdateBatch(circulationCollectionsRes.getUpdateBatch());//SimpleFieldAssign//sourceId:910211_1_40670
//implementActualValueCalcFormulaAnalysisComReqDto.setWorkCycleUpdateSlice(circulationCollectionsRes.getWorkCycleUpdateSlice());//SimpleFieldAssign//sourceId:910212_1_40670
//implementActualValueCalcFormulaAnalysisComReqDto.setStandardDataCalcCycleModel(circulationCollectionsRes.getStandardDataCalcCycleModel()!=null?String.valueOf(circulationCollectionsRes.getStandardDataCalcCycleModel()):"");//SimpleFieldAssign//sourceId:910199_1_40670
//    }
//if(queryPrepareForCalcContentDetailComRespDto!=null){
//      implementActualValueCalcFormulaAnalysisComReqDto.setEvaObjTypeCode(queryPrepareForCalcContentDetailComRespDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:910198_1_40670
//implementActualValueCalcFormulaAnalysisComReqDto.setTargetCycleContentTypeCode(queryPrepareForCalcContentDetailComRespDto.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:910197_1_40670
//implementActualValueCalcFormulaAnalysisComReqDto.setTargetValueType(queryPrepareForCalcContentDetailComRespDto.getTargetValueType());//SimpleFieldAssign//sourceId:910194_1_40670
//implementActualValueCalcFormulaAnalysisComReqDto.setIndicatorKind(queryPrepareForCalcContentDetailComRespDto.getIndicatorKind());//SimpleFieldAssign//sourceId:910204_1_40670
//implementActualValueCalcFormulaAnalysisComReqDto.setIsLastObjective(queryPrepareForCalcContentDetailComRespDto.getIsLastObjective());//SimpleFieldAssign//sourceId:910195_1_40670
//implementActualValueCalcFormulaAnalysisComReqDto.setCalculateDataSource(queryPrepareForCalcContentDetailComRespDto.getCalculateDataSource());//SimpleFieldAssign//sourceId:910196_1_40670
//implementActualValueCalcFormulaAnalysisComReqDto.setQuantityObjectiveNoValue(queryPrepareForCalcContentDetailComRespDto.getQuantityObjectiveNoValue());//SimpleFieldAssign//sourceId:910203_1_40670
//    }
//
//    /*D4-执行实际值公式分析(公共)[6389]   */
//    Assert.isNull(implementActualValueCalcFormulaAnalysisComReqDto.getSchemeDataPara(),"D3-执行重新计算标准数据(公共)-D4-执行实际值公式分析(公共)-评价模板数据参数不能为空",false);
//Assert.isNull(implementActualValueCalcFormulaAnalysisComReqDto.getReportType(),"D3-执行重新计算标准数据(公共)-D4-执行实际值公式分析(公共)-汇报类型不能为空",false);
//Assert.isNull(implementActualValueCalcFormulaAnalysisComReqDto.getIsOkrPlanScene(),"D3-执行重新计算标准数据(公共)-D4-执行实际值公式分析(公共)-冗余开启OKR场景不能为空",false);
//Assert.isNull(implementActualValueCalcFormulaAnalysisComReqDto.getIsOpenSubReportLimit(),"D3-执行重新计算标准数据(公共)-D4-执行实际值公式分析(公共)-是否开启下级汇报限制不能为空",false);
//Assert.isNull(implementActualValueCalcFormulaAnalysisComReqDto.getLastCycleType(),"D3-执行重新计算标准数据(公共)-D4-执行实际值公式分析(公共)-末级周期类型不能为空",false);
//Assert.isNull(implementActualValueCalcFormulaAnalysisComReqDto.getDecimalPointRules(),"D3-执行重新计算标准数据(公共)-D4-执行实际值公式分析(公共)-小数点规则不能为空",false);
//Assert.isNull(implementActualValueCalcFormulaAnalysisComReqDto.getDecimalDigitsLastRules(),"D3-执行重新计算标准数据(公共)-D4-执行实际值公式分析(公共)-小数最后一位规则不能为空",false);
//Assert.isNull(implementActualValueCalcFormulaAnalysisComReqDto.getEvaObjTargetCycleId(),"D3-执行重新计算标准数据(公共)-D4-执行实际值公式分析(公共)-被评对象目标周期ID不能为空",false);
//Assert.isNull(implementActualValueCalcFormulaAnalysisComReqDto.getEvaObjTypeCode(),"D3-执行重新计算标准数据(公共)-D4-执行实际值公式分析(公共)-被评对象类型编码不能为空",false);
//Assert.isNull(implementActualValueCalcFormulaAnalysisComReqDto.getTargetCycleContentTypeCode(),"D3-执行重新计算标准数据(公共)-D4-执行实际值公式分析(公共)-关联目标内容类型编码不能为空",false);
//Assert.isNull(implementActualValueCalcFormulaAnalysisComReqDto.getEvaluationTemplateId(),"D3-执行重新计算标准数据(公共)-D4-执行实际值公式分析(公共)-冗余评价模板ID不能为空",false);
//Assert.isNull(implementActualValueCalcFormulaAnalysisComReqDto.getCycleId(),"D3-执行重新计算标准数据(公共)-D4-执行实际值公式分析(公共)-周期ID不能为空",false);
//Assert.isNull(implementActualValueCalcFormulaAnalysisComReqDto.getUpdateCycleId(),"D3-执行重新计算标准数据(公共)-D4-执行实际值公式分析(公共)-更新周期ID不能为空",false);
//Assert.isNull(implementActualValueCalcFormulaAnalysisComReqDto.getParentSubMidCycleType(),"D3-执行重新计算标准数据(公共)-D4-执行实际值公式分析(公共)-父子中周期类型不能为空",false);
//Assert.isNull(implementActualValueCalcFormulaAnalysisComReqDto.getUpdateBatch(),"D3-执行重新计算标准数据(公共)-D4-执行实际值公式分析(公共)-数据更新批次（时间点）不能为空",false);
//Assert.isNull(implementActualValueCalcFormulaAnalysisComReqDto.getWorkCycleUpdateSlice(),"D3-执行重新计算标准数据(公共)-D4-执行实际值公式分析(公共)-工作周期更新切片不能为空",false);
//Assert.isNull(implementActualValueCalcFormulaAnalysisComReqDto.getStandardDataCalcCycleModel(),"D3-执行重新计算标准数据(公共)-D4-执行实际值公式分析(公共)-标准数据计算周期模型不能为空",false);
//      implementActualValueCalcFormulaAnalysisComRespDto = fwCalcGridCalculateClient.implementActualValueCalcFormulaAnalysisCom(implementActualValueCalcFormulaAnalysisComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;
//
//
//
//           }
//      }
//else if((circulationCollectionsRes!= null&&  circulationCollectionsRes.getDataType() !=null && circulationCollectionsRes.getDataType().equals("PROGRESS_VALUE")||circulationCollectionsRes!= null&&  circulationCollectionsRes.getDataType() !=null && circulationCollectionsRes.getDataType().equals("FROM_LAST_PROGRESS_VALUE")||circulationCollectionsRes!= null&&  circulationCollectionsRes.getDataType() !=null && circulationCollectionsRes.getDataType().equals("PROGRESS_FROM_LAST_RATIO")||circulationCollectionsRes!= null&&  circulationCollectionsRes.getDataType() !=null && circulationCollectionsRes.getDataType().equals("COUNT_PROGRESS_VALUE"))){
//       //elseif((M3-重新计算全模板内容标准数据【循环开始】.数据类型编码 等于 进度值 or M3-重新计算全模板内容标准数据【循环开始】.数据类型编码 等于 进度较上次变化值 or M3-重新计算全模板内容标准数据【循环开始】.数据类型编码 等于 进度较上次增降幅 or M3-重新计算全模板内容标准数据【循环开始】.数据类型编码 等于 计算进度值))  40671
//
//ImplementProgressValueCalcFormulaAnalysisComRespDto implementProgressValueCalcFormulaAnalysisComRespDto = null;
//    if(queryPrepareForCalcContentDetailComRespDto !=null){
//          ImplementProgressValueCalcFormulaAnalysisComReqDto implementProgressValueCalcFormulaAnalysisComReqDto=new ImplementProgressValueCalcFormulaAnalysisComReqDto();
//  if(reqDto!=null){
//      implementProgressValueCalcFormulaAnalysisComReqDto.setSchemeDataPara(reqDto.getSchemeDataPara());//SimpleFieldAssign//sourceId:910170_1_40672
//implementProgressValueCalcFormulaAnalysisComReqDto.setReportType(reqDto.getReportType());//SimpleFieldAssign//sourceId:910172_1_40672
//implementProgressValueCalcFormulaAnalysisComReqDto.setIsOpenSubReportLimit(reqDto.getIsOpenSubReportLimit());//SimpleFieldAssign//sourceId:910180_1_40672
//implementProgressValueCalcFormulaAnalysisComReqDto.setIsOkrPlanScene(reqDto.getIsOkrPlanScene());//SimpleFieldAssign//sourceId:910175_1_40672
//implementProgressValueCalcFormulaAnalysisComReqDto.setKrWeight(reqDto.getKrWeight());//SimpleFieldAssign//sourceId:910189_1_40672
//implementProgressValueCalcFormulaAnalysisComReqDto.setOWeight(reqDto.getOWeight());//SimpleFieldAssign//sourceId:910190_1_40672
//implementProgressValueCalcFormulaAnalysisComReqDto.setDecimalPointRules(reqDto.getProgressDecimalPoint());//SimpleFieldAssign//sourceId:910186_1_40672
//implementProgressValueCalcFormulaAnalysisComReqDto.setDecimalDigitsLastRules(reqDto.getDecimalDigitsLastRules());//SimpleFieldAssign//sourceId:910187_1_40672
//implementProgressValueCalcFormulaAnalysisComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:910174_1_40672
//    }
//if(circulationCollectionsRes!=null){
//      implementProgressValueCalcFormulaAnalysisComReqDto.setEvaObjTargetCycleId(circulationCollectionsRes.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:910176_1_40672
//implementProgressValueCalcFormulaAnalysisComReqDto.setCycleId(circulationCollectionsRes.getCycleId());//SimpleFieldAssign//sourceId:910177_1_40672
//implementProgressValueCalcFormulaAnalysisComReqDto.setUpdateCycleId(circulationCollectionsRes.getUpdateCycleId());//SimpleFieldAssign//sourceId:910191_1_40672
//implementProgressValueCalcFormulaAnalysisComReqDto.setParentSubMidCycleType(circulationCollectionsRes.getParentSubMidCycleType()!=null?String.valueOf(circulationCollectionsRes.getParentSubMidCycleType()):"");//SimpleFieldAssign//sourceId:910181_1_40672
//implementProgressValueCalcFormulaAnalysisComReqDto.setUpdateBatch(circulationCollectionsRes.getUpdateBatch());//SimpleFieldAssign//sourceId:910185_1_40672
//implementProgressValueCalcFormulaAnalysisComReqDto.setWorkCycleUpdateSlice(circulationCollectionsRes.getWorkCycleUpdateSlice());//SimpleFieldAssign//sourceId:910188_1_40672
//implementProgressValueCalcFormulaAnalysisComReqDto.setStandardDataCalcCycleModel(circulationCollectionsRes.getStandardDataCalcCycleModel()!=null?String.valueOf(circulationCollectionsRes.getStandardDataCalcCycleModel()):"");//SimpleFieldAssign//sourceId:910178_1_40672
//    }
//if(queryPrepareForCalcContentDetailComRespDto!=null){
//      implementProgressValueCalcFormulaAnalysisComReqDto.setEvaObjTypeCode(queryPrepareForCalcContentDetailComRespDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:910179_1_40672
//implementProgressValueCalcFormulaAnalysisComReqDto.setTargetCycleContentTypeCode(queryPrepareForCalcContentDetailComRespDto.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:910173_1_40672
//implementProgressValueCalcFormulaAnalysisComReqDto.setIsLastObjective(queryPrepareForCalcContentDetailComRespDto.getIsLastObjective());//SimpleFieldAssign//sourceId:910171_1_40672
//implementProgressValueCalcFormulaAnalysisComReqDto.setTargetValueType(queryPrepareForCalcContentDetailComRespDto.getTargetValueType());//SimpleFieldAssign//sourceId:910182_1_40672
//implementProgressValueCalcFormulaAnalysisComReqDto.setIndicatorKind(queryPrepareForCalcContentDetailComRespDto.getIndicatorKind());//SimpleFieldAssign//sourceId:910183_1_40672
//implementProgressValueCalcFormulaAnalysisComReqDto.setCalculateDataSource(queryPrepareForCalcContentDetailComRespDto.getCalculateDataSource());//SimpleFieldAssign//sourceId:910184_1_40672
//    }
//
//    /*D4-执行进度值公式分析(公共)[6388]   */
//    Assert.isNull(implementProgressValueCalcFormulaAnalysisComReqDto.getSchemeDataPara(),"D3-执行重新计算标准数据(公共)-D4-执行进度值公式分析(公共)-评价模板数据参数不能为空",false);
//Assert.isNull(implementProgressValueCalcFormulaAnalysisComReqDto.getReportType(),"D3-执行重新计算标准数据(公共)-D4-执行进度值公式分析(公共)-汇报类型不能为空",false);
//Assert.isNull(implementProgressValueCalcFormulaAnalysisComReqDto.getIsOpenSubReportLimit(),"D3-执行重新计算标准数据(公共)-D4-执行进度值公式分析(公共)-是否开启下级汇报限制不能为空",false);
//Assert.isNull(implementProgressValueCalcFormulaAnalysisComReqDto.getIsOkrPlanScene(),"D3-执行重新计算标准数据(公共)-D4-执行进度值公式分析(公共)-冗余开启OKR场景不能为空",false);
//Assert.isNull(implementProgressValueCalcFormulaAnalysisComReqDto.getKrWeight(),"D3-执行重新计算标准数据(公共)-D4-执行进度值公式分析(公共)-下级KR权重不能为空",false);
//Assert.isNull(implementProgressValueCalcFormulaAnalysisComReqDto.getOWeight(),"D3-执行重新计算标准数据(公共)-D4-执行进度值公式分析(公共)-下级O权重不能为空",false);
//Assert.isNull(implementProgressValueCalcFormulaAnalysisComReqDto.getDecimalPointRules(),"D3-执行重新计算标准数据(公共)-D4-执行进度值公式分析(公共)-小数点规则不能为空",false);
//Assert.isNull(implementProgressValueCalcFormulaAnalysisComReqDto.getDecimalDigitsLastRules(),"D3-执行重新计算标准数据(公共)-D4-执行进度值公式分析(公共)-小数最后一位规则不能为空",false);
//Assert.isNull(implementProgressValueCalcFormulaAnalysisComReqDto.getEvaObjTargetCycleId(),"D3-执行重新计算标准数据(公共)-D4-执行进度值公式分析(公共)-被评对象目标周期ID不能为空",false);
//Assert.isNull(implementProgressValueCalcFormulaAnalysisComReqDto.getEvaObjTypeCode(),"D3-执行重新计算标准数据(公共)-D4-执行进度值公式分析(公共)-被评对象类型编码不能为空",false);
//Assert.isNull(implementProgressValueCalcFormulaAnalysisComReqDto.getTargetCycleContentTypeCode(),"D3-执行重新计算标准数据(公共)-D4-执行进度值公式分析(公共)-关联目标内容类型编码不能为空",false);
//Assert.isNull(implementProgressValueCalcFormulaAnalysisComReqDto.getCycleId(),"D3-执行重新计算标准数据(公共)-D4-执行进度值公式分析(公共)-周期ID不能为空",false);
//Assert.isNull(implementProgressValueCalcFormulaAnalysisComReqDto.getUpdateCycleId(),"D3-执行重新计算标准数据(公共)-D4-执行进度值公式分析(公共)-更新周期ID不能为空",false);
//Assert.isNull(implementProgressValueCalcFormulaAnalysisComReqDto.getParentSubMidCycleType(),"D3-执行重新计算标准数据(公共)-D4-执行进度值公式分析(公共)-父子中周期类型不能为空",false);
//Assert.isNull(implementProgressValueCalcFormulaAnalysisComReqDto.getUpdateBatch(),"D3-执行重新计算标准数据(公共)-D4-执行进度值公式分析(公共)-数据更新批次（时间点）不能为空",false);
//Assert.isNull(implementProgressValueCalcFormulaAnalysisComReqDto.getWorkCycleUpdateSlice(),"D3-执行重新计算标准数据(公共)-D4-执行进度值公式分析(公共)-工作周期更新切片不能为空",false);
//Assert.isNull(implementProgressValueCalcFormulaAnalysisComReqDto.getStandardDataCalcCycleModel(),"D3-执行重新计算标准数据(公共)-D4-执行进度值公式分析(公共)-标准数据计算周期模型不能为空",false);
//Assert.isNull(implementProgressValueCalcFormulaAnalysisComReqDto.getEvaluationTemplateId(),"D3-执行重新计算标准数据(公共)-D4-执行进度值公式分析(公共)-冗余评价模板ID不能为空",false);
//      implementProgressValueCalcFormulaAnalysisComRespDto = fwCalcGridCalculateClient.implementProgressValueCalcFormulaAnalysisCom(implementProgressValueCalcFormulaAnalysisComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;
//
//
//
//           }
//    }
//else if((circulationCollectionsRes!= null&&  circulationCollectionsRes.getDataType() !=null && circulationCollectionsRes.getDataType().equals("REPORT_SCORE")||circulationCollectionsRes!= null&&  circulationCollectionsRes.getDataType() !=null && circulationCollectionsRes.getDataType().equals("FROM_LAST_REPORT_SCORE")||circulationCollectionsRes!= null&&  circulationCollectionsRes.getDataType() !=null && circulationCollectionsRes.getDataType().equals("FROM_LAST_RATIO_REPORT_SCORE")||circulationCollectionsRes!= null&&  circulationCollectionsRes.getDataType() !=null && circulationCollectionsRes.getDataType().equals("ACTUAL_SCORE")||circulationCollectionsRes!= null&&  circulationCollectionsRes.getDataType() !=null && circulationCollectionsRes.getDataType().equals("FROM_LAST_ACTUAL_SCORE")||circulationCollectionsRes!= null&&  circulationCollectionsRes.getDataType() !=null && circulationCollectionsRes.getDataType().equals("FROM_LAST_RATIO_ACTUAL_SCORE")||circulationCollectionsRes!= null&&  circulationCollectionsRes.getDataType() !=null && circulationCollectionsRes.getDataType().equals("REACH")||circulationCollectionsRes!= null&&  circulationCollectionsRes.getDataType() !=null && circulationCollectionsRes.getDataType().equals("FROM_LAST_REACH")||circulationCollectionsRes!= null&&  circulationCollectionsRes.getDataType() !=null && circulationCollectionsRes.getDataType().equals("ACTUAL_FROM_LAST_TIME_RATIO"))){
//       //elseif((M3-重新计算全模板内容标准数据【循环开始】.数据类型编码 等于 汇报得分 or M3-重新计算全模板内容标准数据【循环开始】.数据类型编码 等于 汇报得分较上次变化值 or M3-重新计算全模板内容标准数据【循环开始】.数据类型编码 等于 汇报得分较上次增降幅 or M3-重新计算全模板内容标准数据【循环开始】.数据类型编码 等于 实际得分 or M3-重新计算全模板内容标准数据【循环开始】.数据类型编码 等于 实际得分较上次变化值 or M3-重新计算全模板内容标准数据【循环开始】.数据类型编码 等于 实际得分较上次增降幅 or M3-重新计算全模板内容标准数据【循环开始】.数据类型编码 等于 达成度 or M3-重新计算全模板内容标准数据【循环开始】.数据类型编码 等于 达成度较上次变化值 or M3-重新计算全模板内容标准数据【循环开始】.数据类型编码 等于 达成度较上次增降福))  40673
//
//ImplementFiveCycleTypeScoreComRespDto implementFiveCycleTypeScoreComRespDto = null;
//    if(queryPrepareForCalcContentDetailComRespDto !=null){
//          ImplementFiveCycleTypeScoreComReqDto implementFiveCycleTypeScoreComReqDto=new ImplementFiveCycleTypeScoreComReqDto();
//  if(reqDto!=null){
//      implementFiveCycleTypeScoreComReqDto.setCustomField(reqDto.getCustomField());//SimpleFieldAssign//sourceId:910228_1_40674
//implementFiveCycleTypeScoreComReqDto.setSchemeDataPara(reqDto.getSchemeDataPara());//SimpleFieldAssign//sourceId:910216_1_40674
//implementFiveCycleTypeScoreComReqDto.setActualScoreIsOpenLocalLevelScore(reqDto.getActualScoreIsOpenLocalLevelScore());//SimpleFieldAssign//sourceId:910217_1_40674
//implementFiveCycleTypeScoreComReqDto.setIsOkrPlanScene(reqDto.getIsOkrPlanScene());//SimpleFieldAssign//sourceId:910224_1_40674
//implementFiveCycleTypeScoreComReqDto.setOpenOrCloseMidProcess(reqDto.getOpenOrCloseMidProcess());//SimpleFieldAssign//sourceId:910249_1_40674
//implementFiveCycleTypeScoreComReqDto.setLastCycleType(reqDto.getLastCycleType());//SimpleFieldAssign//sourceId:910248_1_40674
//implementFiveCycleTypeScoreComReqDto.setCycleTypeCode(reqDto.getMidOfProcessCycleType());//SimpleFieldAssign//sourceId:910250_1_40674
//implementFiveCycleTypeScoreComReqDto.setDecimalPointRules(reqDto.getScoreDecimalPoint());//SimpleFieldAssign//sourceId:910229_1_40674
//implementFiveCycleTypeScoreComReqDto.setDecimalDigitsLastRules(reqDto.getDecimalDigitsLastRules());//SimpleFieldAssign//sourceId:910230_1_40674
//implementFiveCycleTypeScoreComReqDto.setSubjectiveScoreWeight(reqDto.getSubjectiveScoreWeight());//SimpleFieldAssign//sourceId:910232_1_40674
//implementFiveCycleTypeScoreComReqDto.setObjectiveScoreWeight(reqDto.getObjectiveScoreWeight());//SimpleFieldAssign//sourceId:910233_1_40674
//implementFiveCycleTypeScoreComReqDto.setProcessMidWeight(reqDto.getProcessMidWeight());//SimpleFieldAssign//sourceId:910234_1_40674
//implementFiveCycleTypeScoreComReqDto.setMidReportWeight(reqDto.getMidReportWeight());//SimpleFieldAssign//sourceId:910240_1_40674
//implementFiveCycleTypeScoreComReqDto.setReportAvgScoreWeight(reqDto.getReportAvgScoreWeight());//SimpleFieldAssign//sourceId:910235_1_40674
//implementFiveCycleTypeScoreComReqDto.setProcessReportScoreWeight(reqDto.getProcessReportScoreWeight());//SimpleFieldAssign//sourceId:910236_1_40674
//implementFiveCycleTypeScoreComReqDto.setSubjectiveAndObjectiveScoreWeight(reqDto.getSubjectiveAndObjectiveScoreWeight());//SimpleFieldAssign//sourceId:910237_1_40674
//implementFiveCycleTypeScoreComReqDto.setLocalLevelScoreWeight(reqDto.getLocalLevelScoreWeight());//SimpleFieldAssign//sourceId:910238_1_40674
//implementFiveCycleTypeScoreComReqDto.setLowerLevelScoreWeight(reqDto.getLowerLevelScoreWeight());//SimpleFieldAssign//sourceId:910239_1_40674
//implementFiveCycleTypeScoreComReqDto.setKrWeight(reqDto.getKrWeight());//SimpleFieldAssign//sourceId:910231_1_40674
//implementFiveCycleTypeScoreComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:910222_1_40674
//    }
//if(circulationCollectionsRes!=null){
//      implementFiveCycleTypeScoreComReqDto.setEvaObjTargetCycleId(circulationCollectionsRes.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:910218_1_40674
//implementFiveCycleTypeScoreComReqDto.setCycleId(circulationCollectionsRes.getCycleId());//SimpleFieldAssign//sourceId:910221_1_40674
//implementFiveCycleTypeScoreComReqDto.setUpdateCycleId(circulationCollectionsRes.getUpdateCycleId());//SimpleFieldAssign//sourceId:910245_1_40674
//implementFiveCycleTypeScoreComReqDto.setParentSubMidCycleType(circulationCollectionsRes.getParentSubMidCycleType()!=null?String.valueOf(circulationCollectionsRes.getParentSubMidCycleType()):"");//SimpleFieldAssign//sourceId:910243_1_40674
//implementFiveCycleTypeScoreComReqDto.setUpdateBatch(circulationCollectionsRes.getUpdateBatch());//SimpleFieldAssign//sourceId:910242_1_40674
//implementFiveCycleTypeScoreComReqDto.setStandardDataCalcCycleModel(circulationCollectionsRes.getStandardDataCalcCycleModel()!=null?String.valueOf(circulationCollectionsRes.getStandardDataCalcCycleModel()):"");//SimpleFieldAssign//sourceId:910215_1_40674
//    }
//if(queryPrepareForCalcContentDetailComRespDto!=null){
//      implementFiveCycleTypeScoreComReqDto.setEvaObjTypeCode(queryPrepareForCalcContentDetailComRespDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:910219_1_40674
//implementFiveCycleTypeScoreComReqDto.setComFloatField2(queryPrepareForCalcContentDetailComRespDto.getWeightValue());//SimpleFieldAssign//sourceId:910247_1_40674
//implementFiveCycleTypeScoreComReqDto.setWeightScore(queryPrepareForCalcContentDetailComRespDto.getWeightScore());//SimpleFieldAssign//sourceId:910241_1_40674
//implementFiveCycleTypeScoreComReqDto.setIsSubjectiveScoring(queryPrepareForCalcContentDetailComRespDto.getIsSubjectiveScoring());//SimpleFieldAssign//sourceId:910225_1_40674
//implementFiveCycleTypeScoreComReqDto.setIsObjectiveQuantization(queryPrepareForCalcContentDetailComRespDto.getIsObjectiveQuantization());//SimpleFieldAssign//sourceId:910226_1_40674
//implementFiveCycleTypeScoreComReqDto.setTargetCycleContentTypeCode(queryPrepareForCalcContentDetailComRespDto.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:910220_1_40674
//implementFiveCycleTypeScoreComReqDto.setReportObjectSetCode(queryPrepareForCalcContentDetailComRespDto.getReportObjectSetCode());//SimpleFieldAssign//sourceId:910244_1_40674
//implementFiveCycleTypeScoreComReqDto.setIsLastObjective(queryPrepareForCalcContentDetailComRespDto.getIsLastObjective());//SimpleFieldAssign//sourceId:910227_1_40674
//implementFiveCycleTypeScoreComReqDto.setIndicatorKind(queryPrepareForCalcContentDetailComRespDto.getIndicatorKind());//SimpleFieldAssign//sourceId:910223_1_40674
//implementFiveCycleTypeScoreComReqDto.setTargetValueType(queryPrepareForCalcContentDetailComRespDto.getTargetValueType());//SimpleFieldAssign//sourceId:910252_1_40674
//implementFiveCycleTypeScoreComReqDto.setQuantityObjectiveNoValue(queryPrepareForCalcContentDetailComRespDto.getQuantityObjectiveNoValue());//SimpleFieldAssign//sourceId:910253_1_40674
//implementFiveCycleTypeScoreComReqDto.setCycleStartTime(queryPrepareForCalcContentDetailComRespDto.getSubCycleStarttime());//SimpleFieldAssign//sourceId:910251_1_40674
//    }
//
//    /*D4-执行五类周期得分分析(公共)[6482]   */
//    Assert.isNull(implementFiveCycleTypeScoreComReqDto.getCustomField(),"D3-执行重新计算标准数据(公共)-D4-执行五类周期得分分析(公共)-得分公式不能为空",false);
//Assert.isNull(implementFiveCycleTypeScoreComReqDto.getSchemeDataPara(),"D3-执行重新计算标准数据(公共)-D4-执行五类周期得分分析(公共)-评价模板数据参数不能为空",false);
//Assert.isNull(implementFiveCycleTypeScoreComReqDto.getActualScoreIsOpenLocalLevelScore(),"D3-执行重新计算标准数据(公共)-D4-执行五类周期得分分析(公共)-实际得分是否开启本级得分不能为空",false);
//Assert.isNull(implementFiveCycleTypeScoreComReqDto.getIsOkrPlanScene(),"D3-执行重新计算标准数据(公共)-D4-执行五类周期得分分析(公共)-冗余开启OKR场景不能为空",false);
//Assert.isNull(implementFiveCycleTypeScoreComReqDto.getOpenOrCloseMidProcess(),"D3-执行重新计算标准数据(公共)-D4-执行五类周期得分分析(公共)-开启或不开启过程中期不能为空",false);
//Assert.isNull(implementFiveCycleTypeScoreComReqDto.getLastCycleType(),"D3-执行重新计算标准数据(公共)-D4-执行五类周期得分分析(公共)-末级周期类型不能为空",false);
//Assert.isNull(implementFiveCycleTypeScoreComReqDto.getCycleTypeCode(),"D3-执行重新计算标准数据(公共)-D4-执行五类周期得分分析(公共)-过程中期周期类型不能为空",false);
//Assert.isNull(implementFiveCycleTypeScoreComReqDto.getDecimalPointRules(),"D3-执行重新计算标准数据(公共)-D4-执行五类周期得分分析(公共)-小数点规则不能为空",false);
//Assert.isNull(implementFiveCycleTypeScoreComReqDto.getDecimalDigitsLastRules(),"D3-执行重新计算标准数据(公共)-D4-执行五类周期得分分析(公共)-小数最后一位规则不能为空",false);
//Assert.isNull(implementFiveCycleTypeScoreComReqDto.getSubjectiveScoreWeight(),"D3-执行重新计算标准数据(公共)-D4-执行五类周期得分分析(公共)-主观得分权重不能为空",false);
//Assert.isNull(implementFiveCycleTypeScoreComReqDto.getObjectiveScoreWeight(),"D3-执行重新计算标准数据(公共)-D4-执行五类周期得分分析(公共)-客观得分权重不能为空",false);
//Assert.isNull(implementFiveCycleTypeScoreComReqDto.getProcessMidWeight(),"D3-执行重新计算标准数据(公共)-D4-执行五类周期得分分析(公共)-过程中期权重不能为空",false);
//Assert.isNull(implementFiveCycleTypeScoreComReqDto.getMidReportWeight(),"D3-执行重新计算标准数据(公共)-D4-执行五类周期得分分析(公共)-中期汇报得分权重不能为空",false);
//Assert.isNull(implementFiveCycleTypeScoreComReqDto.getReportAvgScoreWeight(),"D3-执行重新计算标准数据(公共)-D4-执行五类周期得分分析(公共)-汇报平均分权重不能为空",false);
//Assert.isNull(implementFiveCycleTypeScoreComReqDto.getProcessReportScoreWeight(),"D3-执行重新计算标准数据(公共)-D4-执行五类周期得分分析(公共)-过程汇报得分权重不能为空",false);
//Assert.isNull(implementFiveCycleTypeScoreComReqDto.getSubjectiveAndObjectiveScoreWeight(),"D3-执行重新计算标准数据(公共)-D4-执行五类周期得分分析(公共)-主客观得分权重不能为空",false);
//Assert.isNull(implementFiveCycleTypeScoreComReqDto.getLocalLevelScoreWeight(),"D3-执行重新计算标准数据(公共)-D4-执行五类周期得分分析(公共)-本级得分权重不能为空",false);
//Assert.isNull(implementFiveCycleTypeScoreComReqDto.getLowerLevelScoreWeight(),"D3-执行重新计算标准数据(公共)-D4-执行五类周期得分分析(公共)-下级得分权重不能为空",false);
//Assert.isNull(implementFiveCycleTypeScoreComReqDto.getKrWeight(),"D3-执行重新计算标准数据(公共)-D4-执行五类周期得分分析(公共)-下级KR权重不能为空",false);
//Assert.isNull(implementFiveCycleTypeScoreComReqDto.getEvaObjTargetCycleId(),"D3-执行重新计算标准数据(公共)-D4-执行五类周期得分分析(公共)-被评对象目标周期ID不能为空",false);
//Assert.isNull(implementFiveCycleTypeScoreComReqDto.getEvaObjTypeCode(),"D3-执行重新计算标准数据(公共)-D4-执行五类周期得分分析(公共)-被评对象类型编码不能为空",false);
//Assert.isNull(implementFiveCycleTypeScoreComReqDto.getComFloatField2(),"D3-执行重新计算标准数据(公共)-D4-执行五类周期得分分析(公共)-目标树叶子节点权重不能为空",false);
//Assert.isNull(implementFiveCycleTypeScoreComReqDto.getWeightScore(),"D3-执行重新计算标准数据(公共)-D4-执行五类周期得分分析(公共)-权重分值不能为空",false);
//Assert.isNull(implementFiveCycleTypeScoreComReqDto.getIsSubjectiveScoring(),"D3-执行重新计算标准数据(公共)-D4-执行五类周期得分分析(公共)-是否开启主观评分不能为空",false);
//Assert.isNull(implementFiveCycleTypeScoreComReqDto.getIsObjectiveQuantization(),"D3-执行重新计算标准数据(公共)-D4-执行五类周期得分分析(公共)-是否开启量化客观评分不能为空",false);
//Assert.isNull(implementFiveCycleTypeScoreComReqDto.getTargetCycleContentTypeCode(),"D3-执行重新计算标准数据(公共)-D4-执行五类周期得分分析(公共)-关联目标内容类型编码不能为空",false);
//Assert.isNull(implementFiveCycleTypeScoreComReqDto.getEvaluationTemplateId(),"D3-执行重新计算标准数据(公共)-D4-执行五类周期得分分析(公共)-冗余评价模板ID不能为空",false);
//Assert.isNull(implementFiveCycleTypeScoreComReqDto.getCycleId(),"D3-执行重新计算标准数据(公共)-D4-执行五类周期得分分析(公共)-周期ID不能为空",false);
//Assert.isNull(implementFiveCycleTypeScoreComReqDto.getUpdateCycleId(),"D3-执行重新计算标准数据(公共)-D4-执行五类周期得分分析(公共)-更新周期ID不能为空",false);
//Assert.isNull(implementFiveCycleTypeScoreComReqDto.getCycleStartTime(),"D3-执行重新计算标准数据(公共)-D4-执行五类周期得分分析(公共)-子周期周期开始时间不能为空",false);
//Assert.isNull(implementFiveCycleTypeScoreComReqDto.getParentSubMidCycleType(),"D3-执行重新计算标准数据(公共)-D4-执行五类周期得分分析(公共)-父子中周期类型不能为空",false);
//Assert.isNull(implementFiveCycleTypeScoreComReqDto.getUpdateBatch(),"D3-执行重新计算标准数据(公共)-D4-执行五类周期得分分析(公共)-数据更新批次（时间点）不能为空",false);
//Assert.isNull(implementFiveCycleTypeScoreComReqDto.getStandardDataCalcCycleModel(),"D3-执行重新计算标准数据(公共)-D4-执行五类周期得分分析(公共)-标准数据计算周期模型不能为空",false);
//      implementFiveCycleTypeScoreComRespDto = fwCalcGridCalculateClient.implementFiveCycleTypeScoreCom(implementFiveCycleTypeScoreComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;
//
//
//
//           }
//    }
////ModelCode: circulationEnd
//        }
//
//      }
        ImplementRecalcStandardDataComRespDto retData = new ImplementRecalcStandardDataComRespDto();


        return retData;
    }

    /**
     * D3-计算因子接收字段(公共)[6532]
     * gen by moon at 7/5/2023, 1:26:37 AM
     */
    @Trace(operationName = "D3-计算因子接收字段(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementCalcReceivingFieldComRespDto implementCalcReceivingFieldCom(ImplementCalcReceivingFieldComReqDto reqDto) {


        //步骤0: M3-计算接收上文字段（特殊方法） - calculateAcceptAboveFields
        //ModelCode: receptionService
        CalculateAcceptAboveFieldsRespDto receptionServiceRes = null;
        CalculateAcceptAboveFieldsReqDto receptionServiceReq = new CalculateAcceptAboveFieldsReqDto();
        if (reqDto != null) {
            receptionServiceReq.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:907885_1
            receptionServiceReq.setEvaObjTypeCode(reqDto.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:910927_1
            receptionServiceReq.setTargetCycleContentTypeCode(reqDto.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:1006840_1
            receptionServiceReq.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1006841_1
            receptionServiceReq.setCycleId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:907890_1
            receptionServiceReq.setCycleStartTime(reqDto.getCycleStartTime());//SimpleFieldAssign//sourceId:907891_1
            receptionServiceReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:907893_1
            receptionServiceReq.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:907894_1
            receptionServiceReq.setLastCycleType(reqDto.getLastCycleType());//SimpleFieldAssign//sourceId:907895_1
            receptionServiceReq.setFatherCycleType(reqDto.getFatherCycleType());//SimpleFieldAssign//sourceId:907896_1
            receptionServiceReq.setMidCycleType(reqDto.getMidCycleType());//SimpleFieldAssign//sourceId:907897_1
            receptionServiceReq.setStandardDataCalcCycleModel(reqDto.getStandardDataCalcCycleModel());//SimpleFieldAssign//sourceId:1009244_1
            receptionServiceReq.setSubcycleType(reqDto.getSubcycleType());//SimpleFieldAssign//sourceId:907898_1
            receptionServiceReq.setCurrentCycleType(reqDto.getCurrentCycleType());//SimpleFieldAssign//sourceId:907901_1
            receptionServiceReq.setIsFatherCycle(reqDto.getIsFatherCycle());//SimpleFieldAssign//sourceId:1009248_1
            receptionServiceReq.setExecuteCycleStageList(reqDto.getExecuteCycleStageList().stream().map(item -> BeanUtil.toBean(item, ExecuteCycleStageDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:908204_1
            receptionServiceReq.setExecuteCycleStageId(reqDto.getExecuteCycleStageId());//SimpleFieldAssign//sourceId:907904_1
            receptionServiceReq.setIsSubCycle(reqDto.getIsSubCycle());//SimpleFieldAssign//sourceId:1009249_1
            receptionServiceReq.setIsMetaphase(reqDto.getIsMetaphase());//SimpleFieldAssign//sourceId:1009250_1
            receptionServiceReq.setCycleTypeCode(reqDto.getCycleTypeCode());//SimpleFieldAssign//sourceId:907908_1
            receptionServiceReq.setHaveProcessCycle(reqDto.getHaveProcessCycle());//SimpleFieldAssign//sourceId:907909_1
            receptionServiceReq.setCycleMode(reqDto.getCycleMode());//SimpleFieldAssign//sourceId:907910_1
            receptionServiceReq.setTaskId(reqDto.getTaskId());//SimpleFieldAssign//sourceId:907914_1
            receptionServiceReq.setCycleStageDataId(reqDto.getCycleStageDataId());//SimpleFieldAssign//sourceId:907915_1
            receptionServiceReq.setSchemeDataPara(reqDto.getSchemeDataPara());//SimpleFieldAssign//sourceId:907917_1
            receptionServiceReq.setReportType(reqDto.getReportType());//SimpleFieldAssign//sourceId:907918_1
            receptionServiceReq.setActualScoreIsOpenLocalLevelScore(reqDto.getActualScoreIsOpenLocalLevelScore());//SimpleFieldAssign//sourceId:907919_1
            receptionServiceReq.setIsOpenSubReportLimit(reqDto.getIsOpenSubReportLimit());//SimpleFieldAssign//sourceId:907920_1
            receptionServiceReq.setIsOkrPlanScene(reqDto.getIsOkrPlanScene());//SimpleFieldAssign//sourceId:907921_1
            receptionServiceReq.setOpenOrCloseMidProcess(reqDto.getOpenOrCloseMidProcess());//SimpleFieldAssign//sourceId:907924_1
            receptionServiceReq.setOpenOrCloseMidCycle(reqDto.getOpenOrCloseMidCycle());//SimpleFieldAssign//sourceId:907925_1
            receptionServiceReq.setActualValueDecimalPoint(reqDto.getActualValueDecimalPoint());//SimpleFieldAssign//sourceId:907926_1
            receptionServiceReq.setScoreDecimalPoint(reqDto.getScoreDecimalPoint());//SimpleFieldAssign//sourceId:907928_1
            receptionServiceReq.setProgressDecimalPoint(reqDto.getProgressDecimalPoint());//SimpleFieldAssign//sourceId:907930_1
            receptionServiceReq.setDecimalDigitsLastRules(reqDto.getDecimalDigitsLastRules());//SimpleFieldAssign//sourceId:907931_1
            receptionServiceReq.setCustomField(reqDto.getCustomField());//SimpleFieldAssign//sourceId:907932_1
            receptionServiceReq.setSubjectiveScoreWeight(reqDto.getSubjectiveScoreWeight());//SimpleFieldAssign//sourceId:907933_1
            receptionServiceReq.setObjectiveScoreWeight(reqDto.getObjectiveScoreWeight());//SimpleFieldAssign//sourceId:907934_1
            receptionServiceReq.setProcessReportScoreProMidWeight(reqDto.getProcessReportScoreProMidWeight());//SimpleFieldAssign//sourceId:907935_1
            receptionServiceReq.setProcessReportScoreAvgWeight(reqDto.getProcessReportScoreAvgWeight());//SimpleFieldAssign//sourceId:907936_1
            receptionServiceReq.setProcessReportScoreKrWeight(reqDto.getProcessReportScoreKrWeight());//SimpleFieldAssign//sourceId:907937_1
            receptionServiceReq.setReportScoreProcessWeight(reqDto.getReportScoreProcessWeight());//SimpleFieldAssign//sourceId:907938_1
            receptionServiceReq.setReportScoreSubAndObjWeight(reqDto.getReportScoreSubAndObjWeight());//SimpleFieldAssign//sourceId:907939_1
            receptionServiceReq.setActualScoreLocalLevelWeight(reqDto.getActualScoreLocalLevelWeight());//SimpleFieldAssign//sourceId:907940_1
            receptionServiceReq.setActualScoreLowerLevelWeight(reqDto.getActualScoreLowerLevelWeight());//SimpleFieldAssign//sourceId:907941_1
            receptionServiceReq.setProcessReportScoreMidWeight(reqDto.getProcessReportScoreMidWeight());//SimpleFieldAssign//sourceId:907942_1
            receptionServiceReq.setOWeight(reqDto.getOWeight());//SimpleFieldAssign//sourceId:907943_1
            receptionServiceReq.setUpdateCycleId(reqDto.getUpdateCycleId());//SimpleFieldAssign//sourceId:1009307_1
            receptionServiceReq.setMidOfProcessCycleType(reqDto.getMidOfProcessCycleType());//SimpleFieldAssign//sourceId:907944_1
            receptionServiceReq.setIsDefinedExecuteCycleStage(reqDto.getIsDefinedExecuteCycleStage());//SimpleFieldAssign//sourceId:908131_1
            receptionServiceReq.setTargetId(reqDto.getTargetId());//SimpleFieldAssign//sourceId:1009260_1
            receptionServiceReq.setSubObjectWeight(reqDto.getSubObjectWeight());//SimpleFieldAssign//sourceId:960578_1
            receptionServiceReq.setSubjectiveRatingTotalValue(reqDto.getSubjectiveRatingTotalValue());//SimpleFieldAssign//sourceId:976943_1
            receptionServiceReq.setCountProObWeight(reqDto.getCountProObWeight());//SimpleFieldAssign//sourceId:988140_1
            receptionServiceReq.setCountProKrWeight(reqDto.getCountProKrWeight());//SimpleFieldAssign//sourceId:988141_1
            receptionServiceReq.setExecuteProgressValue(reqDto.getExecuteProgressValue());//SimpleFieldAssign//sourceId:1077877_1
            receptionServiceReq.setUseTypeCode(reqDto.getUseTypeCode());//SimpleFieldAssign//sourceId:1077878_1
            receptionServiceReq.setSubCycleIsLastCycle(reqDto.getSubCycleIsLastCycle());//SimpleFieldAssign//sourceId:1054710_1
            receptionServiceReq.setSubjectiveRatingTotalValueUnit(reqDto.getSubjectiveRatingTotalValueUnit());//SimpleFieldAssign//sourceId:1058239_1
        }

        /*M3-计算接收上文字段（特殊方法）[6495]  用于特殊方法接收上游入参。 */

        receptionServiceRes = nbGridCalculate.calculateAcceptAboveFields(receptionServiceReq);


        ImplementCalcReceivingFieldComRespDto retData = new ImplementCalcReceivingFieldComRespDto();


        return retData;
    }


    /**
     * D3-审核汇报任务资料和标准数据(公共)[6376]
     * gen by moon at 6/8/2024, 8:39:05 PM
     */
    @Trace(operationName = "D3-审核汇报任务资料和标准数据(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ApproveSucceedReportTaskComRespDto approveSucceedReportTaskCom(ApproveSucceedReportTaskComReqDto reqDto) {


//virtualUsage D3-3更新周期阶段资料(公共)  50794
        RefreshCycleStageDataComRespDto refreshCycleStageDataComRespDto = null;
        RefreshCycleStageDataComReqDto refreshCycleStageDataComReqDto = new RefreshCycleStageDataComReqDto();
        if (reqDto != null) {
            refreshCycleStageDataComReqDto.setCycleStageDataId(reqDto.getCycleStageDataId());//SimpleFieldAssign//sourceId:868149_1_50794
            refreshCycleStageDataComReqDto.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:868152_1_50794
            refreshCycleStageDataComReqDto.setCycleId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:868151_1_50794
        }

        /*D3-3更新周期阶段资料(公共)[3154]   */
        Assert.isNull(refreshCycleStageDataComReqDto.getCycleStageDataId(), "D3-审核汇报任务资料和标准数据(公共)-D3-3更新周期阶段资料(公共)-周期阶段资料记录ID不能为空", false);
        Assert.isNull(refreshCycleStageDataComReqDto.getEvaObjTargetCycleId(), "D3-审核汇报任务资料和标准数据(公共)-D3-3更新周期阶段资料(公共)-被评对象目标周期ID不能为空", false);
        Assert.isNull(refreshCycleStageDataComReqDto.getCycleId(), "D3-审核汇报任务资料和标准数据(公共)-D3-3更新周期阶段资料(公共)-周期ID不能为空", false);
        refreshCycleStageDataComRespDto = cycleStageDataService.refreshCycleStageDataCom(refreshCycleStageDataComReqDto)/*vcase invoke isSameApp*/;


//virtualUsage 3-7-01修改任务  67686
        boolean bOOLEAN;
        OmsTask omsTask = new OmsTask();
        omsTask.setPercentageProgress(Double.valueOf("100"));//CUSTOM_CONVENTION//sourceId:1765177_1_67686
        if (reqDto != null) {
            omsTask.setTaskId(reqDto.getTaskId());//SimpleFieldAssign//sourceId:1765176_1_67686
        }

        /*3-7-01修改任务[2706]   */
        Assert.isNull(omsTask.getTaskId(), "D3-审核汇报任务资料和标准数据(公共)-3-7-01修改任务-任务ID不能为空", false);
        Assert.isNull(omsTask.getPercentageProgress(), "D3-审核汇报任务资料和标准数据(公共)-3-7-01修改任务-冗余最新进度不能为空", false);
        bOOLEAN = mOmsTaskService.updateTask(omsTask)/*vcase invoke 本地 method 方法调用;*/;


//virtualUsage 11111D4-审核通过标准数据(公共)  67682
        ApproveSucceedStandardDataComRespDto approveSucceedStandardDataComRespDto = null;
        ApproveSucceedStandardDataComReqDto approveSucceedStandardDataComReqDto = new ApproveSucceedStandardDataComReqDto();
        if (reqDto != null) {
            approveSucceedStandardDataComReqDto.setEventBatchUpdateCode(reqDto.getDataObjectBatchCode());//SimpleFieldAssign//sourceId:1764655_1_67682
            approveSucceedStandardDataComReqDto.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1764652_1_67682
            approveSucceedStandardDataComReqDto.setCycleId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:1764653_1_67682
            approveSucceedStandardDataComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1764654_1_67682
        }

        /*11111D4-审核通过标准数据(公共)[5687]   */
        Assert.isNull(approveSucceedStandardDataComReqDto.getEventBatchUpdateCode(), "D3-审核汇报任务资料和标准数据(公共)-11111D4-审核通过标准数据(公共)-事务内数据更新批次标识不能为空", false);
        Assert.isNull(approveSucceedStandardDataComReqDto.getEvaObjTargetCycleId(), "D3-审核汇报任务资料和标准数据(公共)-11111D4-审核通过标准数据(公共)-被评对象目标周期ID不能为空", false);
        Assert.isNull(approveSucceedStandardDataComReqDto.getCycleId(), "D3-审核汇报任务资料和标准数据(公共)-11111D4-审核通过标准数据(公共)-周期ID不能为空", false);
        Assert.isNull(approveSucceedStandardDataComReqDto.getEvaluationTemplateId(), "D3-审核汇报任务资料和标准数据(公共)-11111D4-审核通过标准数据(公共)-冗余评价模板ID不能为空", false);
        approveSucceedStandardDataComRespDto = fwCalcStandardDataClient.approveSucceedStandardDataCom(approveSucceedStandardDataComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


        ApproveSucceedReportTaskComRespDto retData = new ApproveSucceedReportTaskComRespDto();


        return retData;
    }

    /**
     * D3-根据目标周期查询目标内容父中周期(公共)[7116]
     * gen by moon at 6/2/2023, 2:58:33 PM
     */
    @Trace(operationName = "D3-根据目标周期查询目标内容父中周期(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementFatherAndMidTargetCycleIDComRespDto implementFatherAndMidTargetCycleIDCom(ImplementFatherAndMidTargetCycleIDComReqDto reqDto) {


        OmsEvaluationObjectTargetCycle omsEvaluationObjectTargetCycle_3 = null;
        OmsEvaluationObjectTargetCycle omsEvaluationObjectTargetCycle_5 = null;
//步骤0: 3-3-09查被评对象目标周期详情 - queryEvaObjTargetCycleDetail
        OmsEvaluationObjectTargetCycle omsEvaluationObjectTargetCycle = null;
        QueryEvaObjTargetCycleDetailReq queryEvaObjTargetCycleDetailReq = new QueryEvaObjTargetCycleDetailReq();
        queryEvaObjTargetCycleDetailReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1004549_1
        if (reqDto != null) {
            queryEvaObjTargetCycleDetailReq.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1004547_1
            queryEvaObjTargetCycleDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1004548_1
        }

        /*3-3-09查目标周期详情（获取内容信息）[2313]   */
        Assert.isNull(queryEvaObjTargetCycleDetailReq.getEvaObjTargetCycleId(), "D3-根据目标周期查询目标内容父中周期(公共)-3-3-09查目标周期详情（获取内容信息）-被评对象目标周期ID不能为空", false);
        Assert.isNull(queryEvaObjTargetCycleDetailReq.getEvaluationTemplateId(), "D3-根据目标周期查询目标内容父中周期(公共)-3-3-09查目标周期详情（获取内容信息）-冗余评价模板ID不能为空", false);
        Assert.isNull(queryEvaObjTargetCycleDetailReq.getSubjectLifeCycle(), "D3-根据目标周期查询目标内容父中周期(公共)-3-3-09查目标周期详情（获取内容信息）-主体生命周期不能为空", false);
        omsEvaluationObjectTargetCycle = mOmsEvaluationObjectTargetCycleService.queryEvaObjTargetCycleDetail(queryEvaObjTargetCycleDetailReq)/*vcase invoke 本地 method 方法调用;*/;


//步骤1: 3-3-09查被评对象目标周期详情 - queryEvaObjTargetCycleDetail
        OmsEvaluationObjectTargetCycle omsEvaluationObjectTargetCycle_2 = null;
        if (omsEvaluationObjectTargetCycle != null) {
            QueryEvaObjTargetCycleDetailReq queryEvaObjTargetCycleDetailReq_1 = new QueryEvaObjTargetCycleDetailReq();
            queryEvaObjTargetCycleDetailReq_1.setIsParentCycle("TRUE");//sourceId:1004722_1
            queryEvaObjTargetCycleDetailReq_1.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1004724_1
            if (omsEvaluationObjectTargetCycle != null) {
                queryEvaObjTargetCycleDetailReq_1.setEvaObjEntityId(omsEvaluationObjectTargetCycle.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1004717_1
                queryEvaObjTargetCycleDetailReq_1.setEvaObjTableTypeCode(omsEvaluationObjectTargetCycle.getEvaObjTableTypeCode());//SimpleFieldAssign//sourceId:1004718_1
                queryEvaObjTargetCycleDetailReq_1.setEvaObjTypeCode(omsEvaluationObjectTargetCycle.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1004719_1
                queryEvaObjTargetCycleDetailReq_1.setTreeTypeCode(omsEvaluationObjectTargetCycle.getTreeTypeCode());//SimpleFieldAssign//sourceId:1004720_1
                queryEvaObjTargetCycleDetailReq_1.setTargetCycleContentId(omsEvaluationObjectTargetCycle.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1004721_1
            }
            if (reqDto != null) {
                queryEvaObjTargetCycleDetailReq_1.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1004723_1
            }

            /*3-3-09查目标内容父周期[2313]   */
            Assert.isNull(queryEvaObjTargetCycleDetailReq_1.getEvaObjEntityId(), "D3-根据目标周期查询目标内容父中周期(公共)-3-3-09查目标内容父周期-被评对象内容表主键ID不能为空", false);
            Assert.isNull(queryEvaObjTargetCycleDetailReq_1.getEvaObjTableTypeCode(), "D3-根据目标周期查询目标内容父中周期(公共)-3-3-09查目标内容父周期-被评对象内容表类型编码不能为空", false);
            Assert.isNull(queryEvaObjTargetCycleDetailReq_1.getEvaObjTypeCode(), "D3-根据目标周期查询目标内容父中周期(公共)-3-3-09查目标内容父周期-被评对象类型编码不能为空", false);
            Assert.isNull(queryEvaObjTargetCycleDetailReq_1.getTreeTypeCode(), "D3-根据目标周期查询目标内容父中周期(公共)-3-3-09查目标内容父周期-树类型编码不能为空", false);
            Assert.isNull(queryEvaObjTargetCycleDetailReq_1.getTargetCycleContentId(), "D3-根据目标周期查询目标内容父中周期(公共)-3-3-09查目标内容父周期-关联目标内容ID不能为空", false);
            Assert.isNull(queryEvaObjTargetCycleDetailReq_1.getEvaluationTemplateId(), "D3-根据目标周期查询目标内容父中周期(公共)-3-3-09查目标内容父周期-冗余评价模板ID不能为空", false);
            Assert.isNull(queryEvaObjTargetCycleDetailReq_1.getSubjectLifeCycle(), "D3-根据目标周期查询目标内容父中周期(公共)-3-3-09查目标内容父周期-主体生命周期不能为空", false);
            omsEvaluationObjectTargetCycle_2 = mOmsEvaluationObjectTargetCycleService.queryEvaObjTargetCycleDetail(queryEvaObjTargetCycleDetailReq_1)/*vcase invoke 本地 method 方法调用;*/;


            omsEvaluationObjectTargetCycle_3 = omsEvaluationObjectTargetCycle_2;
        }

//步骤2: 3-3-09查被评对象目标周期详情 - queryEvaObjTargetCycleDetail
        OmsEvaluationObjectTargetCycle omsEvaluationObjectTargetCycle_4 = null;
        if (omsEvaluationObjectTargetCycle != null) {
            QueryEvaObjTargetCycleDetailReq queryEvaObjTargetCycleDetailReq_2 = new QueryEvaObjTargetCycleDetailReq();
            queryEvaObjTargetCycleDetailReq_2.setIsMetaphase("TRUE");//sourceId:1004714_1
            queryEvaObjTargetCycleDetailReq_2.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1004716_1
            if (omsEvaluationObjectTargetCycle != null) {
                queryEvaObjTargetCycleDetailReq_2.setEvaObjEntityId(omsEvaluationObjectTargetCycle.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1004709_1
                queryEvaObjTargetCycleDetailReq_2.setEvaObjTableTypeCode(omsEvaluationObjectTargetCycle.getEvaObjTableTypeCode());//SimpleFieldAssign//sourceId:1004710_1
                queryEvaObjTargetCycleDetailReq_2.setEvaObjTypeCode(omsEvaluationObjectTargetCycle.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1004711_1
                queryEvaObjTargetCycleDetailReq_2.setTreeTypeCode(omsEvaluationObjectTargetCycle.getTreeTypeCode());//SimpleFieldAssign//sourceId:1004712_1
                queryEvaObjTargetCycleDetailReq_2.setTargetCycleContentId(omsEvaluationObjectTargetCycle.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1004713_1
            }
            if (reqDto != null) {
                queryEvaObjTargetCycleDetailReq_2.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1004715_1
            }

            /*3-3-09查目标周期中期[2313]   */
            Assert.isNull(queryEvaObjTargetCycleDetailReq_2.getEvaObjEntityId(), "D3-根据目标周期查询目标内容父中周期(公共)-3-3-09查目标周期中期-被评对象内容表主键ID不能为空", false);
            Assert.isNull(queryEvaObjTargetCycleDetailReq_2.getEvaObjTableTypeCode(), "D3-根据目标周期查询目标内容父中周期(公共)-3-3-09查目标周期中期-被评对象内容表类型编码不能为空", false);
            Assert.isNull(queryEvaObjTargetCycleDetailReq_2.getEvaObjTypeCode(), "D3-根据目标周期查询目标内容父中周期(公共)-3-3-09查目标周期中期-被评对象类型编码不能为空", false);
            Assert.isNull(queryEvaObjTargetCycleDetailReq_2.getTreeTypeCode(), "D3-根据目标周期查询目标内容父中周期(公共)-3-3-09查目标周期中期-树类型编码不能为空", false);
            Assert.isNull(queryEvaObjTargetCycleDetailReq_2.getTargetCycleContentId(), "D3-根据目标周期查询目标内容父中周期(公共)-3-3-09查目标周期中期-关联目标内容ID不能为空", false);
            Assert.isNull(queryEvaObjTargetCycleDetailReq_2.getIsMetaphase(), "D3-根据目标周期查询目标内容父中周期(公共)-3-3-09查目标周期中期-是否中期不能为空", false);
            Assert.isNull(queryEvaObjTargetCycleDetailReq_2.getEvaluationTemplateId(), "D3-根据目标周期查询目标内容父中周期(公共)-3-3-09查目标周期中期-冗余评价模板ID不能为空", false);
            Assert.isNull(queryEvaObjTargetCycleDetailReq_2.getSubjectLifeCycle(), "D3-根据目标周期查询目标内容父中周期(公共)-3-3-09查目标周期中期-主体生命周期不能为空", false);
            omsEvaluationObjectTargetCycle_4 = mOmsEvaluationObjectTargetCycleService.queryEvaObjTargetCycleDetail(queryEvaObjTargetCycleDetailReq_2)/*vcase invoke 本地 method 方法调用;*/;


            omsEvaluationObjectTargetCycle_5 = omsEvaluationObjectTargetCycle_4;
        }

        ImplementFatherAndMidTargetCycleIDComRespDto retData = new ImplementFatherAndMidTargetCycleIDComRespDto();
        if (omsEvaluationObjectTargetCycle_3 != null) {
            retData.setFatherEvaObjTargetCycleId(omsEvaluationObjectTargetCycle_3.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1004727_1
        }
        if (omsEvaluationObjectTargetCycle_5 != null) {
            retData.setMidEvaObjTargetCycleId(omsEvaluationObjectTargetCycle_5.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1004728_1
        }


        return retData;
    }


    /**
     * D3分析汇报任务筛选父子中周期类型(公共)[7136]
     * gen by moon at 9/12/2024, 7:18:35 PM
     */
    @Trace(operationName = "D3分析汇报任务筛选父子中周期类型(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementComRespDto implementCom(ImplementComReqDto reqDto) {


        CalculateAcceptAboveFieldsRespDto receptionServiceRes_3 = null;
//virtualUsage M3约定父中子过程周期类型  72821
//ModelCode: receptionService
        ImplementElevenReceivingFieldRespDto receptionServiceRes = null;
        ImplementElevenReceivingFieldReqDto receptionServiceReq = new ImplementElevenReceivingFieldReqDto();
        receptionServiceReq.setCustomField1("PARENT_CYCLE");//CUSTOM_CONVENTION//sourceId:1999614_1_72821
        receptionServiceReq.setCustomField2("MID_CYCLE");//CUSTOM_CONVENTION//sourceId:1999615_1_72821
        receptionServiceReq.setCustomField3("SUB_CYCLE");//CUSTOM_CONVENTION//sourceId:1999616_1_72821
        receptionServiceReq.setCustomField4("PROCESS_CYCLE");//CUSTOM_CONVENTION//sourceId:1999617_1_72821

        /*M3约定父中子过程周期类型[9482]  用于特殊方法接收上游入参。 */
        Assert.isNull(receptionServiceReq.getCustomField1(), "D3分析汇报任务筛选父子中周期类型(公共)-M3约定父中子过程周期类型-自定义字段1不能为空", false);
        Assert.isNull(receptionServiceReq.getCustomField2(), "D3分析汇报任务筛选父子中周期类型(公共)-M3约定父中子过程周期类型-自定义字段2不能为空", false);
        Assert.isNull(receptionServiceReq.getCustomField3(), "D3分析汇报任务筛选父子中周期类型(公共)-M3约定父中子过程周期类型-自定义字段3不能为空", false);
        Assert.isNull(receptionServiceReq.getCustomField4(), "D3分析汇报任务筛选父子中周期类型(公共)-M3约定父中子过程周期类型-自定义字段4不能为空", false);
        receptionServiceRes = nbGridCalculate.implementElevenReceivingField(receptionServiceReq);


        if ((reqDto != null && reqDto.getIsFatherCycle() != null && reqDto.getIsFatherCycle().equals("TRUE") && reqDto != null && reqDto.getIsSubCycle() != null && reqDto.getIsSubCycle().equals("FALSE") && reqDto != null && reqDto.getIsMetaphase() != null && reqDto.getIsMetaphase().equals("FALSE"))) {
            //if((D3-执行父子中周期分析(公共).是否父周期 等于 是 and D3-执行父子中周期分析(公共).是否子周期 等于 否 and D3-执行父子中周期分析(公共).是否中期 等于 否))  44332

//ModelCode: receptionService
            CalculateAcceptAboveFieldsRespDto receptionServiceRes_2 = null;
            CalculateAcceptAboveFieldsReqDto receptionServiceReq_1 = new CalculateAcceptAboveFieldsReqDto();
            if (receptionServiceRes != null) {
                receptionServiceReq_1.setParentSubMidCycleType(receptionServiceRes.getCustomField1());//SimpleFieldAssign//sourceId:1999186_1_44333
            }

            /*约定出参[6495]  用于特殊方法接收上游入参。 */
            Assert.isNull(receptionServiceReq_1.getParentSubMidCycleType(), "D3分析汇报任务筛选父子中周期类型(公共)-约定出参-父子中过程周期类型不能为空", false);
            receptionServiceRes_2 = nbGridCalculate.calculateAcceptAboveFields(receptionServiceReq_1);


            receptionServiceRes_3 = receptionServiceRes_2;
        } else if ((reqDto != null && reqDto.getIsFatherCycle() != null && reqDto.getIsFatherCycle().equals("TRUE") && reqDto != null && reqDto.getIsSubCycle() != null && reqDto.getIsSubCycle().equals("TRUE") && reqDto != null && reqDto.getIsMetaphase() != null && reqDto.getIsMetaphase().equals("FALSE"))) {
            //elseif((D3-执行父子中周期分析(公共).是否父周期 等于 是 and D3-执行父子中周期分析(公共).是否子周期 等于 是 and D3-执行父子中周期分析(公共).是否中期 等于 否))  44334

//ModelCode: receptionService
            CalculateAcceptAboveFieldsRespDto receptionServiceRes_4 = null;
            CalculateAcceptAboveFieldsReqDto receptionServiceReq_2 = new CalculateAcceptAboveFieldsReqDto();
            if (reqDto != null) {
                receptionServiceReq_2.setCycleId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:1011202_1_44335
            }
            if (receptionServiceRes != null) {
                receptionServiceReq_2.setParentSubMidCycleType(receptionServiceRes.getCustomField1());//SimpleFieldAssign//sourceId:1999186_1_44335
            }

            /*约定出参[6495]  用于特殊方法接收上游入参。 */
            Assert.isNull(receptionServiceReq_2.getParentSubMidCycleType(), "D3分析汇报任务筛选父子中周期类型(公共)-约定出参-父子中过程周期类型不能为空", false);
            receptionServiceRes_4 = nbGridCalculate.calculateAcceptAboveFields(receptionServiceReq_2);


            receptionServiceRes_3 = receptionServiceRes_4;
        } else if ((reqDto != null && reqDto.getIsMetaphase() != null && reqDto.getIsMetaphase().equals("TRUE") && reqDto != null && reqDto.getIsFatherCycle() != null && reqDto.getIsFatherCycle().equals("FALSE") && reqDto != null && reqDto.getIsSubCycle() != null && reqDto.getIsSubCycle().equals("FALSE"))) {
            //elseif((D3-执行父子中周期分析(公共).是否中期 等于 是 and D3-执行父子中周期分析(公共).是否父周期 等于 否 and D3-执行父子中周期分析(公共).是否子周期 等于 否))  44336

//ModelCode: receptionService
            CalculateAcceptAboveFieldsRespDto receptionServiceRes_5 = null;
            CalculateAcceptAboveFieldsReqDto receptionServiceReq_3 = new CalculateAcceptAboveFieldsReqDto();
            if (receptionServiceRes != null) {
                receptionServiceReq_3.setParentSubMidCycleType(receptionServiceRes.getCustomField2());//SimpleFieldAssign//sourceId:1999186_1_44337
            }

            /*约定出参[6495]  用于特殊方法接收上游入参。 */
            Assert.isNull(receptionServiceReq_3.getParentSubMidCycleType(), "D3分析汇报任务筛选父子中周期类型(公共)-约定出参-父子中过程周期类型不能为空", false);
            receptionServiceRes_5 = nbGridCalculate.calculateAcceptAboveFields(receptionServiceReq_3);


            receptionServiceRes_3 = receptionServiceRes_5;
        } else if ((reqDto != null && reqDto.getIsSubCycle() != null && reqDto.getIsSubCycle().equals("TRUE") && reqDto != null && reqDto.getIsFatherCycle() != null && reqDto.getIsFatherCycle().equals("FALSE") && reqDto != null && reqDto.getIsMetaphase() != null && reqDto.getIsMetaphase().equals("FALSE"))) {
            //elseif((D3-执行父子中周期分析(公共).是否子周期 等于 是 and D3-执行父子中周期分析(公共).是否父周期 等于 否 and D3-执行父子中周期分析(公共).是否中期 等于 否))  72822

//ModelCode: receptionService
            CalculateAcceptAboveFieldsRespDto receptionServiceRes_6 = null;
            CalculateAcceptAboveFieldsReqDto receptionServiceReq_4 = new CalculateAcceptAboveFieldsReqDto();
            if (reqDto != null) {
                receptionServiceReq_4.setCycleId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:1011202_1_72823
            }
            if (receptionServiceRes != null) {
                receptionServiceReq_4.setParentSubMidCycleType(receptionServiceRes.getCustomField3());//SimpleFieldAssign//sourceId:1999186_1_72823
            }

            /*约定出参[6495]  用于特殊方法接收上游入参。 */
            Assert.isNull(receptionServiceReq_4.getParentSubMidCycleType(), "D3分析汇报任务筛选父子中周期类型(公共)-约定出参-父子中过程周期类型不能为空", false);
            receptionServiceRes_6 = nbGridCalculate.calculateAcceptAboveFields(receptionServiceReq_4);


            receptionServiceRes_3 = receptionServiceRes_6;
        } else if ((reqDto != null && reqDto.getIsFatherCycle() != null && reqDto.getIsFatherCycle().equals("FALSE") && reqDto != null && reqDto.getIsSubCycle() != null && reqDto.getIsSubCycle().equals("FALSE") && reqDto != null && reqDto.getIsMetaphase() != null && reqDto.getIsMetaphase().equals("FALSE"))) {
            //elseif((D3-执行父子中周期分析(公共).是否父周期 值等于空  and D3-执行父子中周期分析(公共).是否子周期 值等于空  and D3-执行父子中周期分析(公共).是否中期 值等于空 ))  72824

//ModelCode: receptionService
            CalculateAcceptAboveFieldsRespDto receptionServiceRes_7 = null;
            CalculateAcceptAboveFieldsReqDto receptionServiceReq_5 = new CalculateAcceptAboveFieldsReqDto();
            if (reqDto != null) {
                receptionServiceReq_5.setCycleId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:1011202_1_72825
            }
            if (receptionServiceRes != null) {
                receptionServiceReq_5.setParentSubMidCycleType(receptionServiceRes.getCustomField4());//SimpleFieldAssign//sourceId:1999186_1_72825
            }

            /*约定出参[6495]  用于特殊方法接收上游入参。 */
            Assert.isNull(receptionServiceReq_5.getParentSubMidCycleType(), "D3分析汇报任务筛选父子中周期类型(公共)-约定出参-父子中过程周期类型不能为空", false);
            receptionServiceRes_7 = nbGridCalculate.calculateAcceptAboveFields(receptionServiceReq_5);


            receptionServiceRes_3 = receptionServiceRes_7;
        }
        ImplementComRespDto retData = new ImplementComRespDto();
        if (receptionServiceRes_3 != null) {
            retData.setCycleId(receptionServiceRes_3.getCycleId());//SimpleFieldAssign//sourceId:1011207_1
            retData.setParentSubMidCycleType(receptionServiceRes_3.getParentSubMidCycleType());//SimpleFieldAssign//sourceId:1999632_1
        }


        return retData;
    }


    /**
     * D3-目标过程周期的执行周期分析（新）(公共)[7139]
     * gen by moon at 6/5/2023, 8:50:14 PM
     */
    @Trace(operationName = "D3-目标过程周期的执行周期分析（新）(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementTargetCycleProExecCycleAnalysisNewComRespDto implementTargetCycleProExecCycleAnalysisNewCom(ImplementTargetCycleProExecCycleAnalysisNewComReqDto reqDto) {


        //virtualUsage D3-查询目标内容及目标内容扩展信息（本级无实际值标识）  44353
        QueryTargetContentAndExtendInfoDetailComRespDto queryTargetContentAndExtendInfoDetailComRespDto = null;
        QueryTargetContentAndExtendInfoDetailComReqDto queryTargetContentAndExtendInfoDetailComReqDto = new QueryTargetContentAndExtendInfoDetailComReqDto();
        if (reqDto != null) {
            queryTargetContentAndExtendInfoDetailComReqDto.setTargetCycleContentTypeCode(reqDto.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:1011725_1_44353
            queryTargetContentAndExtendInfoDetailComReqDto.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1011726_1_44353
            queryTargetContentAndExtendInfoDetailComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1011727_1_44353
        }

        /*D3-查询目标内容及目标内容扩展信息（本级无实际值标识）[6148]   */
        Assert.isNull(queryTargetContentAndExtendInfoDetailComReqDto.getTargetCycleContentTypeCode(), "D3-目标过程周期的执行周期分析（新）(公共)-D3-查询目标内容及目标内容扩展信息（本级无实际值标识）-关联目标内容类型编码不能为空", false);
        Assert.isNull(queryTargetContentAndExtendInfoDetailComReqDto.getTargetCycleContentId(), "D3-目标过程周期的执行周期分析（新）(公共)-D3-查询目标内容及目标内容扩展信息（本级无实际值标识）-关联目标内容ID不能为空", false);
        Assert.isNull(queryTargetContentAndExtendInfoDetailComReqDto.getEvaluationTemplateId(), "D3-目标过程周期的执行周期分析（新）(公共)-D3-查询目标内容及目标内容扩展信息（本级无实际值标识）-冗余评价模板ID不能为空", false);
        queryTargetContentAndExtendInfoDetailComRespDto = targetContentService.queryTargetContentAndExtendInfoDetailCom(queryTargetContentAndExtendInfoDetailComReqDto)/*vcase invoke isSameApp*/;


        if ((queryTargetContentAndExtendInfoDetailComRespDto != null && queryTargetContentAndExtendInfoDetailComRespDto.getIsOpenCustomReport() != null && queryTargetContentAndExtendInfoDetailComRespDto.getIsOpenCustomReport().equals("FALSE"))) {
            //if(D3-查询目标内容及扩展信息（是否自定义汇报及自定义执行周期）.是否开启自定义汇报 等于 否)  44354

//ModelCode: circulationCollections
            for (Object circulationCollectionsRes : new ArrayList()) { //设计工具未关联参数,请联系调整

//ModelCode: circulationEnd
            }

        } else if ((queryTargetContentAndExtendInfoDetailComRespDto != null && queryTargetContentAndExtendInfoDetailComRespDto.getIsOpenCustomReport() != null && queryTargetContentAndExtendInfoDetailComRespDto.getIsOpenCustomReport().equals("TRUE"))) {
            //elseif(D3-查询目标内容及扩展信息（是否自定义汇报及自定义执行周期）.是否开启自定义汇报 等于 是)  44357

            OmsExecuteCycleStage omsExecuteCycleStage = null;
            QueryExecuteCycleStageDetailReq queryExecuteCycleStageDetailReq = new QueryExecuteCycleStageDetailReq();


            /*3-3-07查询执行周期阶段详情[2429]   */
            Assert.isNull(queryExecuteCycleStageDetailReq.getExecuteCycleStageId(), "D3-目标过程周期的执行周期分析（新）(公共)-3-3-07查询执行周期阶段详情-执行周期阶段ID不能为空", false);
            Assert.isNull(queryExecuteCycleStageDetailReq.getCycleId(), "D3-目标过程周期的执行周期分析（新）(公共)-3-3-07查询执行周期阶段详情-周期ID不能为空", false);
            Assert.isNull(queryExecuteCycleStageDetailReq.getCycleStartTime(), "D3-目标过程周期的执行周期分析（新）(公共)-3-3-07查询执行周期阶段详情-周期开始时间不能为空", false);
            Assert.isNull(queryExecuteCycleStageDetailReq.getCycleEndTime(), "D3-目标过程周期的执行周期分析（新）(公共)-3-3-07查询执行周期阶段详情-周期结束时间不能为空", false);
            Assert.isNull(queryExecuteCycleStageDetailReq.getCycleTypeCode(), "D3-目标过程周期的执行周期分析（新）(公共)-3-3-07查询执行周期阶段详情-周期类型标识不能为空", false);
            Assert.isNull(queryExecuteCycleStageDetailReq.getIsProcessCycleStage(), "D3-目标过程周期的执行周期分析（新）(公共)-3-3-07查询执行周期阶段详情-是否过程周期阶段不能为空", false);
            Assert.isNull(queryExecuteCycleStageDetailReq.getRelateContentTypeCode(), "D3-目标过程周期的执行周期分析（新）(公共)-3-3-07查询执行周期阶段详情-关联目标内容类型编码不能为空", false);
            Assert.isNull(queryExecuteCycleStageDetailReq.getRelateContentId(), "D3-目标过程周期的执行周期分析（新）(公共)-3-3-07查询执行周期阶段详情-关联目标内容ID不能为空", false);
            Assert.isNull(queryExecuteCycleStageDetailReq.getIsFatherCycle(), "D3-目标过程周期的执行周期分析（新）(公共)-3-3-07查询执行周期阶段详情-是否父周期不能为空", false);
            Assert.isNull(queryExecuteCycleStageDetailReq.getIsSubCycle(), "D3-目标过程周期的执行周期分析（新）(公共)-3-3-07查询执行周期阶段详情-是否子周期不能为空", false);
            Assert.isNull(queryExecuteCycleStageDetailReq.getIsMetaphase(), "D3-目标过程周期的执行周期分析（新）(公共)-3-3-07查询执行周期阶段详情-是否中期不能为空", false);
            Assert.isNull(queryExecuteCycleStageDetailReq.getIsCurrentCycle(), "D3-目标过程周期的执行周期分析（新）(公共)-3-3-07查询执行周期阶段详情-是否当前周期不能为空", false);
            Assert.isNull(queryExecuteCycleStageDetailReq.getIsNextCycle(), "D3-目标过程周期的执行周期分析（新）(公共)-3-3-07查询执行周期阶段详情-是否下一周期不能为空", false);
            Assert.isNull(queryExecuteCycleStageDetailReq.getTargetId(), "D3-目标过程周期的执行周期分析（新）(公共)-3-3-07查询执行周期阶段详情-冗余目标ID不能为空", false);
            Assert.isNull(queryExecuteCycleStageDetailReq.getEvaluationTemplateId(), "D3-目标过程周期的执行周期分析（新）(公共)-3-3-07查询执行周期阶段详情-评价模板ID不能为空", false);
            Assert.isNull(queryExecuteCycleStageDetailReq.getIsArchive(), "D3-目标过程周期的执行周期分析（新）(公共)-3-3-07查询执行周期阶段详情-是否存档不能为空", false);
            Assert.isNull(queryExecuteCycleStageDetailReq.getSubjectLifeCycle(), "D3-目标过程周期的执行周期分析（新）(公共)-3-3-07查询执行周期阶段详情-主体生命周期不能为空", false);
            Assert.isNull(queryExecuteCycleStageDetailReq.getSpaceId(), "D3-目标过程周期的执行周期分析（新）(公共)-3-3-07查询执行周期阶段详情-创建于空间ID不能为空", false);
            Assert.isNull(queryExecuteCycleStageDetailReq.getAppId(), "D3-目标过程周期的执行周期分析（新）(公共)-3-3-07查询执行周期阶段详情-创建于联盟应用ID不能为空", false);
            Assert.isNull(queryExecuteCycleStageDetailReq.getIsStartCycle(), "D3-目标过程周期的执行周期分析（新）(公共)-3-3-07查询执行周期阶段详情-是否开始周期不能为空", false);
            Assert.isNull(queryExecuteCycleStageDetailReq.getIsDefinedExecuteCycleStage(), "D3-目标过程周期的执行周期分析（新）(公共)-3-3-07查询执行周期阶段详情-是否自定义执行周期阶段不能为空", false);
            omsExecuteCycleStage = mOmsExecuteCycleStageService.queryExecuteCycleStageDetail(queryExecuteCycleStageDetailReq)/*vcase invoke 本地 method 方法调用;*/;


            List<OmsExecuteCycleStage> listOmsExecuteCycleStage = new ArrayList<>();
            QueryExecuteCycleStageListReq queryExecuteCycleStageListReq = new QueryExecuteCycleStageListReq();


            /*3-3-07查询执行周期阶段列表（开始小于等于&结束大于等于）[3201]   */
            Assert.isNull(queryExecuteCycleStageListReq.getEvaObjTargetCycleId(), "D3-目标过程周期的执行周期分析（新）(公共)-3-3-07查询执行周期阶段列表（开始小于等于&结束大于等于）-被评对象目标周期ID不能为空", false);
            Assert.isNull(queryExecuteCycleStageListReq.getCycleId(), "D3-目标过程周期的执行周期分析（新）(公共)-3-3-07查询执行周期阶段列表（开始小于等于&结束大于等于）-周期ID不能为空", false);
            Assert.isNull(queryExecuteCycleStageListReq.getCycleTypeCode(), "D3-目标过程周期的执行周期分析（新）(公共)-3-3-07查询执行周期阶段列表（开始小于等于&结束大于等于）-周期类型标识不能为空", false);
            Assert.isNull(queryExecuteCycleStageListReq.getCycleStartTime(), "D3-目标过程周期的执行周期分析（新）(公共)-3-3-07查询执行周期阶段列表（开始小于等于&结束大于等于）-周期开始时间不能为空", false);
            Assert.isNull(queryExecuteCycleStageListReq.getCycleEndTime(), "D3-目标过程周期的执行周期分析（新）(公共)-3-3-07查询执行周期阶段列表（开始小于等于&结束大于等于）-周期结束时间不能为空", false);
            Assert.isNull(queryExecuteCycleStageListReq.getFillStartTime(), "D3-目标过程周期的执行周期分析（新）(公共)-3-3-07查询执行周期阶段列表（开始小于等于&结束大于等于）-填报开始时间不能为空", false);
            Assert.isNull(queryExecuteCycleStageListReq.getFillEndtTime(), "D3-目标过程周期的执行周期分析（新）(公共)-3-3-07查询执行周期阶段列表（开始小于等于&结束大于等于）-填报结束时间不能为空", false);
            Assert.isNull(queryExecuteCycleStageListReq.getIsProcessCycleStage(), "D3-目标过程周期的执行周期分析（新）(公共)-3-3-07查询执行周期阶段列表（开始小于等于&结束大于等于）-是否过程周期阶段不能为空", false);
            Assert.isNull(queryExecuteCycleStageListReq.getIsDefinedExecuteCycleStage(), "D3-目标过程周期的执行周期分析（新）(公共)-3-3-07查询执行周期阶段列表（开始小于等于&结束大于等于）-是否自定义执行周期阶段不能为空", false);
            Assert.isNull(queryExecuteCycleStageListReq.getRelateContentTypeCode(), "D3-目标过程周期的执行周期分析（新）(公共)-3-3-07查询执行周期阶段列表（开始小于等于&结束大于等于）-关联目标内容类型编码不能为空", false);
            Assert.isNull(queryExecuteCycleStageListReq.getRelateContentId(), "D3-目标过程周期的执行周期分析（新）(公共)-3-3-07查询执行周期阶段列表（开始小于等于&结束大于等于）-关联目标内容ID不能为空", false);
            Assert.isNull(queryExecuteCycleStageListReq.getTargetId(), "D3-目标过程周期的执行周期分析（新）(公共)-3-3-07查询执行周期阶段列表（开始小于等于&结束大于等于）-冗余目标ID不能为空", false);
            Assert.isNull(queryExecuteCycleStageListReq.getEvaluationTemplateId(), "D3-目标过程周期的执行周期分析（新）(公共)-3-3-07查询执行周期阶段列表（开始小于等于&结束大于等于）-评价模板ID不能为空", false);
            Assert.isNull(queryExecuteCycleStageListReq.getIsSubCycle(), "D3-目标过程周期的执行周期分析（新）(公共)-3-3-07查询执行周期阶段列表（开始小于等于&结束大于等于）-是否子周期不能为空", false);
            Assert.isNull(queryExecuteCycleStageListReq.getIsFatherCycle(), "D3-目标过程周期的执行周期分析（新）(公共)-3-3-07查询执行周期阶段列表（开始小于等于&结束大于等于）-是否父周期不能为空", false);
            Assert.isNull(queryExecuteCycleStageListReq.getIsMetaphase(), "D3-目标过程周期的执行周期分析（新）(公共)-3-3-07查询执行周期阶段列表（开始小于等于&结束大于等于）-是否中期不能为空", false);
            Assert.isNull(queryExecuteCycleStageListReq.getIsLastCycle(), "D3-目标过程周期的执行周期分析（新）(公共)-3-3-07查询执行周期阶段列表（开始小于等于&结束大于等于）-是否末级周期不能为空", false);
            Assert.isNull(queryExecuteCycleStageListReq.getSubjectLifeCycle(), "D3-目标过程周期的执行周期分析（新）(公共)-3-3-07查询执行周期阶段列表（开始小于等于&结束大于等于）-主体生命周期不能为空", false);
            Assert.isNull(queryExecuteCycleStageListReq.getIsArchive(), "D3-目标过程周期的执行周期分析（新）(公共)-3-3-07查询执行周期阶段列表（开始小于等于&结束大于等于）-是否存档不能为空", false);
            Assert.isNull(queryExecuteCycleStageListReq.getSpaceId(), "D3-目标过程周期的执行周期分析（新）(公共)-3-3-07查询执行周期阶段列表（开始小于等于&结束大于等于）-创建于空间ID不能为空", false);
            Assert.isNull(queryExecuteCycleStageListReq.getAppId(), "D3-目标过程周期的执行周期分析（新）(公共)-3-3-07查询执行周期阶段列表（开始小于等于&结束大于等于）-创建于联盟应用ID不能为空", false);
            listOmsExecuteCycleStage = mOmsExecuteCycleStageService.queryExecuteCycleStageList(queryExecuteCycleStageListReq)/*vcase invoke 本地 method 方法调用;*/;


            if ((listOmsExecuteCycleStage != null && listOmsExecuteCycleStage != null && listOmsExecuteCycleStage.size() > 0)) {
                //if(3-3-07查询执行周期阶段列表（开始小于等于&结束大于等于）.执行周期阶段列表数据集条数 大于 0)  44360

//ModelCode: circulationCollections
                for (Object circulationCollectionsRes_2 : new ArrayList()) { //设计工具未关联参数,请联系调整

//ModelCode: circulationEnd
                }

            }
        }
        ImplementTargetCycleProExecCycleAnalysisNewComRespDto retData = new ImplementTargetCycleProExecCycleAnalysisNewComRespDto();


        return retData;
    }

    /**
     * D3-执行计算进度参照值元素分析(公共)[7152]
     * gen by moon at 6/6/2023, 11:11:22 PM
     */
    @Trace(operationName = "D3-执行计算进度参照值元素分析(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementActualValueCalcReferenceAnalysisComRespDto implementActualValueCalcReferenceAnalysisCom(ImplementActualValueCalcReferenceAnalysisComReqDto reqDto) {


        CalculateAcceptAboveFieldsRespDto receptionServiceRes_5 = null;
        //virtualUsage 约定：0  44537
        //ModelCode: receptionService
        CalculateAcceptAboveFieldsRespDto receptionServiceRes = null;
        CalculateAcceptAboveFieldsReqDto receptionServiceReq = new CalculateAcceptAboveFieldsReqDto();
        receptionServiceReq.setComNumField(Long.valueOf(0));//CUSTOM_CONVENTION//sourceId:1018196_1_44537

        /*约定：0[6495]  用于特殊方法接收上游入参。 */
        Assert.isNull(receptionServiceReq.getComNumField(), "D3-执行计算进度参照值元素分析(公共)-约定：0-通用数值字段（整数型）不能为空", false);
        receptionServiceRes = nbGridCalculate.calculateAcceptAboveFields(receptionServiceReq);


//virtualUsage 约定：1  44538
        //ModelCode: receptionService
        CalculateAcceptAboveFieldsRespDto receptionServiceRes_2 = null;
        CalculateAcceptAboveFieldsReqDto receptionServiceReq_1 = new CalculateAcceptAboveFieldsReqDto();
        receptionServiceReq_1.setComNumField(Long.valueOf(1));//CUSTOM_CONVENTION//sourceId:1018200_1_44538

        /*约定：1[6495]  用于特殊方法接收上游入参。 */
        Assert.isNull(receptionServiceReq_1.getComNumField(), "D3-执行计算进度参照值元素分析(公共)-约定：1-通用数值字段（整数型）不能为空", false);
        receptionServiceRes_2 = nbGridCalculate.calculateAcceptAboveFields(receptionServiceReq_1);


        if ((reqDto != null && reqDto.getSchemeDataPara() != null && reqDto.getSchemeDataPara().equals("PROCESS_TYPE") || reqDto != null && reqDto.getSchemeDataPara() != null && reqDto.getSchemeDataPara().equals("MIXED_TYPE"))) {
            //if((D3-执行计算进度参照值元素分析(公共).评价模板数据参数 等于 进度型 or D3-执行计算进度参照值元素分析(公共).评价模板数据参数 等于 混合型))  44523

            if ((reqDto != null && reqDto.getIsAutoReport() != null && reqDto.getIsAutoReport().equals("TRUE"))) {
                //if(D3-执行计算进度参照值元素分析(公共).是否自动汇报 等于 是)  44525

                if ((reqDto != null && reqDto.getIsLastObjective() != null && reqDto.getIsLastObjective().equals("TRUE") && reqDto != null && reqDto.getIsOkrPlanScene() != null && reqDto.getIsOkrPlanScene().equals("OKR_PLAN_SCENE"))) {
                    //if((D3-执行计算进度参照值元素分析(公共).是否末级指标 等于 是 and D3-执行计算进度参照值元素分析(公共).冗余开启OKR场景 等于 OKR场景))  44532

//ModelCode: receptionService
                    CalculateAcceptAboveFieldsRespDto receptionServiceRes_4 = null;
                    CalculateAcceptAboveFieldsReqDto receptionServiceReq_2 = new CalculateAcceptAboveFieldsReqDto();
                    if (receptionServiceRes != null) {
                        receptionServiceReq_2.setProgressValueCalcReference(receptionServiceRes.getComNumField());//SimpleFieldAssign//sourceId:1018193_1_44539
                    }
                    if (receptionServiceRes_2 != null) {
                        receptionServiceReq_2.setProgressValueCalcReferenceAndCopy(receptionServiceRes_2.getComNumField());//SimpleFieldAssign//sourceId:1018194_1_44539
                    }

                    /*约定出参：进度值计算参照值元素[6495]  用于特殊方法接收上游入参。 */

                    receptionServiceRes_4 = nbGridCalculate.calculateAcceptAboveFields(receptionServiceReq_2);


                    receptionServiceRes_5 = receptionServiceRes_4;
                } else if ((reqDto != null && reqDto.getIsLastObjective() != null && reqDto.getIsLastObjective().equals("FALSE"))) {
                    //elseif(D3-执行计算进度参照值元素分析(公共).是否末级指标 等于 否)  44533

//ModelCode: receptionService
                    CalculateAcceptAboveFieldsRespDto receptionServiceRes_6 = null;
                    CalculateAcceptAboveFieldsReqDto receptionServiceReq_3 = new CalculateAcceptAboveFieldsReqDto();
                    if (receptionServiceRes != null) {
                        receptionServiceReq_3.setProgressValueCalcReference(receptionServiceRes.getComNumField());//SimpleFieldAssign//sourceId:1018193_1_44610
                    }
                    if (receptionServiceRes_2 != null) {
                        receptionServiceReq_3.setProgressValueCalcReferenceAndCopy(receptionServiceRes_2.getComNumField());//SimpleFieldAssign//sourceId:1018194_1_44610
                    }

                    /*约定出参：进度值计算参照值元素[6495]  用于特殊方法接收上游入参。 */

                    receptionServiceRes_6 = nbGridCalculate.calculateAcceptAboveFields(receptionServiceReq_3);


                    receptionServiceRes_5 = receptionServiceRes_6;
                } else if ((reqDto != null && reqDto.getTargetCycleContentTypeCode() != null && reqDto.getTargetCycleContentTypeCode().equals("TARGET_CATEGORY"))) {
                    //elseif(D3-执行计算进度参照值元素分析(公共).关联目标内容类型编码 等于 目标分类)  44608

//ModelCode: receptionService
                    CalculateAcceptAboveFieldsRespDto receptionServiceRes_7 = null;
                    CalculateAcceptAboveFieldsReqDto receptionServiceReq_4 = new CalculateAcceptAboveFieldsReqDto();
                    if (receptionServiceRes != null) {
                        receptionServiceReq_4.setProgressValueCalcReference(receptionServiceRes.getComNumField());//SimpleFieldAssign//sourceId:1018193_1_44609
                    }
                    if (receptionServiceRes_2 != null) {
                        receptionServiceReq_4.setProgressValueCalcReferenceAndCopy(receptionServiceRes_2.getComNumField());//SimpleFieldAssign//sourceId:1018194_1_44609
                    }

                    /*约定出参：进度值计算参照值元素[6495]  用于特殊方法接收上游入参。 */

                    receptionServiceRes_7 = nbGridCalculate.calculateAcceptAboveFields(receptionServiceReq_4);


                    receptionServiceRes_5 = receptionServiceRes_7;
                }
            } else if ((reqDto != null && reqDto.getIsAutoReport() != null && reqDto.getIsAutoReport().equals("FALSE"))) {
                //elseif(D3-执行计算进度参照值元素分析(公共).是否自动汇报 等于 否)  44611

//ModelCode: receptionService
                CalculateAcceptAboveFieldsRespDto receptionServiceRes_8 = null;
                CalculateAcceptAboveFieldsReqDto receptionServiceReq_5 = new CalculateAcceptAboveFieldsReqDto();
                if (receptionServiceRes_2 != null) {
                    receptionServiceReq_5.setProgressValueCalcReference(receptionServiceRes_2.getComNumField());//SimpleFieldAssign//sourceId:1018193_1_44612
                }
                if (receptionServiceRes != null) {
                    receptionServiceReq_5.setProgressValueCalcReferenceAndCopy(receptionServiceRes.getComNumField());//SimpleFieldAssign//sourceId:1018194_1_44612
                }

                /*约定出参：进度值计算参照值元素[6495]  用于特殊方法接收上游入参。 */

                receptionServiceRes_8 = nbGridCalculate.calculateAcceptAboveFields(receptionServiceReq_5);


                receptionServiceRes_5 = receptionServiceRes_8;
            }
        }
        ImplementActualValueCalcReferenceAnalysisComRespDto retData = new ImplementActualValueCalcReferenceAnalysisComRespDto();
        if (receptionServiceRes_5 != null) {
            retData.setProgressValueCalcReference(receptionServiceRes_5.getProgressValueCalcReference());//SimpleFieldAssign//sourceId:1019227_1
            retData.setProgressValueCalcReferenceAndCopy(receptionServiceRes_5.getProgressValueCalcReferenceAndCopy());//SimpleFieldAssign//sourceId:1019228_1
        }


        return retData;
    }

    /**
     * D3-执行计算目标参照值元素分析(公共)[7153]
     * gen by moon at 6/6/2023, 11:11:37 PM
     */
    @Trace(operationName = "D3-执行计算目标参照值元素分析(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementProgressValueCalcReferenceAnalysisComRespDto implementProgressValueCalcReferenceAnalysisCom(ImplementProgressValueCalcReferenceAnalysisComReqDto reqDto) {


        CalculateAcceptAboveFieldsRespDto receptionServiceRes_5 = null;
        //virtualUsage 约定：0  44549
        //ModelCode: receptionService
        CalculateAcceptAboveFieldsRespDto receptionServiceRes = null;
        CalculateAcceptAboveFieldsReqDto receptionServiceReq = new CalculateAcceptAboveFieldsReqDto();
        receptionServiceReq.setComNumField(Long.valueOf(0));//CUSTOM_CONVENTION//sourceId:1018799_1_44549

        /*约定：0[6495]  用于特殊方法接收上游入参。 */

        receptionServiceRes = nbGridCalculate.calculateAcceptAboveFields(receptionServiceReq);


//virtualUsage 约定：1  44550
        //ModelCode: receptionService
        CalculateAcceptAboveFieldsRespDto receptionServiceRes_2 = null;
        CalculateAcceptAboveFieldsReqDto receptionServiceReq_1 = new CalculateAcceptAboveFieldsReqDto();
        receptionServiceReq_1.setComNumField(Long.valueOf(1));//CUSTOM_CONVENTION//sourceId:1018800_1_44550

        /*约定：1[6495]  用于特殊方法接收上游入参。 */
        Assert.isNull(receptionServiceReq_1.getComNumField(), "D3-执行计算目标参照值元素分析(公共)-约定：1-通用数值字段（整数型）不能为空", false);
        receptionServiceRes_2 = nbGridCalculate.calculateAcceptAboveFields(receptionServiceReq_1);


        if ((reqDto != null && reqDto.getTargetCycleContentTypeCode() != null && reqDto.getTargetCycleContentTypeCode().equals("OBJECTIVE") && reqDto != null && reqDto.getIsLastObjective() != null && reqDto.getIsLastObjective().equals("FALSE") && reqDto != null && reqDto.getCalculateDataSource() != null && reqDto.getCalculateDataSource().equals("MANUAL_FILLING"))) {
            //if((D3-执行计算目标参照值元素分析(公共).关联目标内容类型编码 等于 指标 and D3-执行计算目标参照值元素分析(公共).是否末级指标 等于 否 and D3-执行计算目标参照值元素分析(公共).计算数据来源 等于 人工填报))  44551

            if ((reqDto != null && reqDto.getIsAutoReport() != null && reqDto.getIsAutoReport().equals("TRUE"))) {
                //if(D3-执行计算目标参照值元素分析(公共).是否自动汇报 等于 是)  44553

//ModelCode: receptionService
                CalculateAcceptAboveFieldsRespDto receptionServiceRes_4 = null;
                CalculateAcceptAboveFieldsReqDto receptionServiceReq_2 = new CalculateAcceptAboveFieldsReqDto();
                if (receptionServiceRes != null) {
                    receptionServiceReq_2.setActualValueCalcReference(receptionServiceRes.getComNumField());//SimpleFieldAssign//sourceId:1018802_1_44616
                }
                if (receptionServiceRes_2 != null) {
                    receptionServiceReq_2.setActualValueCalcReferenceAndCopy(receptionServiceRes_2.getComNumField());//SimpleFieldAssign//sourceId:1018803_1_44616
                }

                /*约定出参：实际值计算参照值元素[6495]  用于特殊方法接收上游入参。 */

                receptionServiceRes_4 = nbGridCalculate.calculateAcceptAboveFields(receptionServiceReq_2);


                receptionServiceRes_5 = receptionServiceRes_4;
            } else if ((reqDto != null && reqDto.getIsAutoReport() != null && reqDto.getIsAutoReport().equals("FALSE"))) {
                //elseif(D3-执行计算目标参照值元素分析(公共).是否自动汇报 等于 否)  44614

//ModelCode: receptionService
                CalculateAcceptAboveFieldsRespDto receptionServiceRes_6 = null;
                CalculateAcceptAboveFieldsReqDto receptionServiceReq_3 = new CalculateAcceptAboveFieldsReqDto();
                if (receptionServiceRes_2 != null) {
                    receptionServiceReq_3.setActualValueCalcReference(receptionServiceRes_2.getComNumField());//SimpleFieldAssign//sourceId:1018802_1_44615
                }
                if (receptionServiceRes != null) {
                    receptionServiceReq_3.setActualValueCalcReferenceAndCopy(receptionServiceRes.getComNumField());//SimpleFieldAssign//sourceId:1018803_1_44615
                }

                /*约定出参：实际值计算参照值元素[6495]  用于特殊方法接收上游入参。 */

                receptionServiceRes_6 = nbGridCalculate.calculateAcceptAboveFields(receptionServiceReq_3);


                receptionServiceRes_5 = receptionServiceRes_6;
            }
        }
        ImplementProgressValueCalcReferenceAnalysisComRespDto retData = new ImplementProgressValueCalcReferenceAnalysisComRespDto();
        if (receptionServiceRes_5 != null) {
            retData.setActualValueCalcReference(receptionServiceRes_5.getActualValueCalcReference());//SimpleFieldAssign//sourceId:1019223_1
            retData.setActualValueCalcReferenceAndCopy(receptionServiceRes_5.getActualValueCalcReferenceAndCopy());//SimpleFieldAssign//sourceId:1019224_1
        }


        return retData;
    }

    /**
     * D3-执行周期阶段资料处理(公共)[7156]
     * gen by moon at 1/2/2024, 8:42:04 PM
     */
    @Trace(operationName = "D3-执行周期阶段资料处理(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementCycleStageDataComRespDto implementCycleStageDataCom(ImplementCycleStageDataComReqDto reqDto) {


        //virtualUsage D2-3查评价模板数据参数  44658
        QueryConfItemMatchAnswerDetailComRespDto queryConfItemMatchAnswerDetailComRespDto = null;
        com.wicket.okrcomponent.integration.dto.QueryConfItemMatchAnswerDetailComReqDto queryConfItemMatchAnswerDetailComReqDto = new com.wicket.okrcomponent.integration.dto.QueryConfItemMatchAnswerDetailComReqDto();
        queryConfItemMatchAnswerDetailComReqDto.setResultAspObjType("EVA_TEMP");//sourceId:1020937_1_44658
        queryConfItemMatchAnswerDetailComReqDto.setConfItemCode("SCHEME_DATA_PARA");//CUSTOM_CONVENTION//sourceId:1020936_1_44658
        queryConfItemMatchAnswerDetailComReqDto.setIsPlatData("FALSE");//sourceId:1020945_1_44658
        if (reqDto != null) {
            queryConfItemMatchAnswerDetailComReqDto.setResultAspObjId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1020938_1_44658
        }

        /*D2-3查评价模板数据参数[2486]   */
        Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getResultAspObjId(), "D3-执行周期阶段资料处理(公共)-D2-3查评价模板数据参数-开通对象ID不能为空", false);
        Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getResultAspObjType(), "D3-执行周期阶段资料处理(公共)-D2-3查评价模板数据参数-开通对象类型编码不能为空", false);
        Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getConfItemCode(), "D3-执行周期阶段资料处理(公共)-D2-3查评价模板数据参数-配置项标识不能为空", false);
        Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getIsPlatData(), "D3-执行周期阶段资料处理(公共)-D2-3查评价模板数据参数-是否标准答案不能为空", false);
        queryConfItemMatchAnswerDetailComRespDto = confSchemeService.queryConfItemMatchAnswerDetailCom(queryConfItemMatchAnswerDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


//virtualUsage D3获取目标内容属性信息（是否开启主观评价）  46967
        ObtainTargetContNatureInfoComRespDto obtainTargetContNatureInfoComRespDto = null;
        ObtainTargetContNatureInfoComReqDto obtainTargetContNatureInfoComReqDto = new ObtainTargetContNatureInfoComReqDto();
        if (reqDto != null) {
            obtainTargetContNatureInfoComReqDto.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1077203_1_46967
            obtainTargetContNatureInfoComReqDto.setTargetCycleContentTypeCode(reqDto.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:1077204_1_46967
            obtainTargetContNatureInfoComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1077205_1_46967
        }

        /*D3获取目标内容属性信息（是否开启主观评价）[6952]   */
        Assert.isNull(obtainTargetContNatureInfoComReqDto.getTargetCycleContentId(), "D3-执行周期阶段资料处理(公共)-D3获取目标内容属性信息（是否开启主观评价）-关联目标内容ID不能为空", false);
        Assert.isNull(obtainTargetContNatureInfoComReqDto.getTargetCycleContentTypeCode(), "D3-执行周期阶段资料处理(公共)-D3获取目标内容属性信息（是否开启主观评价）-关联目标内容类型编码不能为空", false);
        obtainTargetContNatureInfoComRespDto = indexSystemService.obtainTargetContNatureInfoCom(obtainTargetContNatureInfoComReqDto)/*vcase invoke isSameApp*/;


//virtualUsage 3-3-11查询周期阶段资料列表  44662
        List<OmsTspeCycleStageData> listOmsTspeCycleStageData = new ArrayList<>();
        QueryCycleStageDataListReq queryCycleStageDataListReq = new QueryCycleStageDataListReq();
        queryCycleStageDataListReq.setCycleDataTypeCode("CYC_STA_DAT");//sourceId:1020925_1_44662
        queryCycleStageDataListReq.setCyclePurposeTypeCode("OBS_TAR_REP");//sourceId:1020928_1_44662
        queryCycleStageDataListReq.setCycleDataObjTypeCode("EVA_OBJ_TARGET_CYCLE");//sourceId:1020929_1_44662
        queryCycleStageDataListReq.setSubjectLifeCycle("EDITING");//sourceId:1020932_1_44662
        if (reqDto != null) {
            queryCycleStageDataListReq.setCycleDataObjId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1020930_1_44662
            queryCycleStageDataListReq.setCycleId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:1020933_1_44662
        }

        /*3-3-11查询周期阶段资料列表[2673]   */
        Assert.isNull(queryCycleStageDataListReq.getCycleDataObjId(), "D3-执行周期阶段资料处理(公共)-3-3-11查询周期阶段资料列表-周期资料归属对象ID不能为空", false);
        Assert.isNull(queryCycleStageDataListReq.getCycleId(), "D3-执行周期阶段资料处理(公共)-3-3-11查询周期阶段资料列表-周期ID不能为空", false);
        Assert.isNull(queryCycleStageDataListReq.getCycleDataTypeCode(), "D3-执行周期阶段资料处理(公共)-3-3-11查询周期阶段资料列表-周期阶段资料类型编码不能为空", false);
        Assert.isNull(queryCycleStageDataListReq.getCyclePurposeTypeCode(), "D3-执行周期阶段资料处理(公共)-3-3-11查询周期阶段资料列表-周期资料用途类型编码不能为空", false);
        Assert.isNull(queryCycleStageDataListReq.getCycleDataObjTypeCode(), "D3-执行周期阶段资料处理(公共)-3-3-11查询周期阶段资料列表-周期资料归属对象类型编码不能为空", false);
        Assert.isNull(queryCycleStageDataListReq.getSubjectLifeCycle(), "D3-执行周期阶段资料处理(公共)-3-3-11查询周期阶段资料列表-主体生命周期不能为空", false);
        listOmsTspeCycleStageData = mOmsTspeCycleStageDataService.queryCycleStageDataList(queryCycleStageDataListReq)/*vcase invoke 本地 method 方法调用;*/;


        if ((queryConfItemMatchAnswerDetailComRespDto != null && queryConfItemMatchAnswerDetailComRespDto.getEndValue() != null && queryConfItemMatchAnswerDetailComRespDto.getEndValue().equals("DOC_TYPE") || obtainTargetContNatureInfoComRespDto != null && obtainTargetContNatureInfoComRespDto.getIsSubjectiveScoring() != null && obtainTargetContNatureInfoComRespDto.getIsSubjectiveScoring().equals("FALSE"))) {
            //if((D2-3查评价模板数据参数.答案值 等于 资料型 or D3获取目标内容属性信息（是否开启主观评价）.是否开启主观评分 等于 否))  44660

            boolean bOOLEAN;
            if (listOmsTspeCycleStageData != null && !CollectionUtil.isEmpty(listOmsTspeCycleStageData) && listOmsTspeCycleStageData.size() > 0) {
                List<OmsTspeCycleStageData> listOmsTspeCycleStageData_2 = new ArrayList<>();
                if (listOmsTspeCycleStageData != null && !CollectionUtil.isEmpty(listOmsTspeCycleStageData) && listOmsTspeCycleStageData != null && !CollectionUtil.isEmpty(listOmsTspeCycleStageData)) {
                    listOmsTspeCycleStageData_2 = //objList-to-objLists
                            listOmsTspeCycleStageData.stream().map(item -> {
                                OmsTspeCycleStageData elm = new OmsTspeCycleStageData();
                                elm.setCycleStageDataId(item.getCycleStageDataId());//SimpleFieldAssign//sourceId:217239_2_44663
                                elm.setOperationInductionId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecInductionRecordId());//CURRENT_INDUCTIONID//sourceId:217241_2_44663
                                elm.setOperateTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:217243_2_44663
                                elm.setActualEndTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:217249_2_44663
                                return elm;
                            }).collect(Collectors.toList());//objList-to-objLists//sourceId:1020970_1_44663
                }

                /*3-3-11批量修改周期阶段资料（无评价）[3342]   */

                bOOLEAN = mOmsTspeCycleStageDataService.batchUpdateCycleStageData(listOmsTspeCycleStageData_2)/*vcase invoke 本地 method 方法调用;*/;


            }
        } else if ((!(queryConfItemMatchAnswerDetailComRespDto != null && queryConfItemMatchAnswerDetailComRespDto.getEndValue() != null && queryConfItemMatchAnswerDetailComRespDto.getEndValue().equals("DOC_TYPE")) && obtainTargetContNatureInfoComRespDto != null && obtainTargetContNatureInfoComRespDto.getIsSubjectiveScoring() != null && obtainTargetContNatureInfoComRespDto.getIsSubjectiveScoring().equals("TRUE"))) {
            //elseif((D2-3查评价模板数据参数.答案值 不等于 资料型 and D3获取目标内容属性信息（是否开启主观评价）.是否开启主观评分 等于 是))  44661

            boolean bOOLEAN_1;
            if (listOmsTspeCycleStageData != null && !CollectionUtil.isEmpty(listOmsTspeCycleStageData) && listOmsTspeCycleStageData.size() > 0) {
                List<OmsTspeCycleStageData> listOmsTspeCycleStageData_3 = new ArrayList<>();
                if (listOmsTspeCycleStageData != null && !CollectionUtil.isEmpty(listOmsTspeCycleStageData) && listOmsTspeCycleStageData != null && !CollectionUtil.isEmpty(listOmsTspeCycleStageData)) {
                    listOmsTspeCycleStageData_3 = //objList-to-objLists
                            listOmsTspeCycleStageData.stream().map(item -> {
                                OmsTspeCycleStageData elm = new OmsTspeCycleStageData();
                                elm.setCycleStageDataId(item.getCycleStageDataId());//SimpleFieldAssign//sourceId:217230_2_44664
                                elm.setActualEndTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:217250_2_44664
                                elm.setOperationInductionId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecInductionRecordId());//CURRENT_INDUCTIONID//sourceId:217232_2_44664
                                elm.setOperateTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:217234_2_44664
                                return elm;
                            }).collect(Collectors.toList());//objList-to-objLists//sourceId:1020935_1_44664
                }

                /*3-3-11批量修改周期阶段资料（待评价）[3342]   */

                bOOLEAN_1 = mOmsTspeCycleStageDataService.batchUpdateCycleStageData(listOmsTspeCycleStageData_3)/*vcase invoke 本地 method 方法调用;*/;


            }
        }
        ImplementCycleStageDataComRespDto retData = new ImplementCycleStageDataComRespDto();


        return retData;
    }

    /**
     * D3-分析最新可循环周期标准数据(公共)[7184]
     * gen by moon at 7/12/2023, 9:52:53 PM
     */
    @Trace(operationName = "D3-分析最新可循环周期标准数据(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementAnalysisCurrentCycleIsUpdateCycleComRespDto implementAnalysisCurrentCycleIsUpdateCycleCom(ImplementAnalysisCurrentCycleIsUpdateCycleComReqDto reqDto) {


        CalculateAcceptAboveFieldsRespDto receptionServiceRes_1 = null;
//virtualUsage D2-执行字符串对比(公共)  45058
        ImplementStringEfficiencyCheckComRespDto implementStringEfficiencyCheckComRespDto = null;
        ImplementStringEfficiencyCheckComReqDto implementStringEfficiencyCheckComReqDto = new ImplementStringEfficiencyCheckComReqDto();
        if (reqDto != null) {
            implementStringEfficiencyCheckComReqDto.setReferenceString(reqDto.getCycleId());//SimpleFieldAssign//sourceId:1030734_1_45058
            implementStringEfficiencyCheckComReqDto.setComparisonString(reqDto.getUpdateCycleId());//SimpleFieldAssign//sourceId:1030735_1_45058
        }

        /*D2-执行字符串对比(公共)[5774]   */

        implementStringEfficiencyCheckComRespDto = interfaceModeService.implementStringEfficiencyCheckCom(implementStringEfficiencyCheckComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


        if ((implementStringEfficiencyCheckComRespDto != null && implementStringEfficiencyCheckComRespDto.getStringEfficiencyCheckResult() != null && implementStringEfficiencyCheckComRespDto.getStringEfficiencyCheckResult().equals("FALSE"))) {
            //if(D2-判断更新周期ID是否等于归属周期ID.字符串对比结果 等于 否)  45059

            ImplementFindSubTargetCycleComRespDto implementFindSubTargetCycleComRespDto = null;
            ImplementFindSubTargetCycleComReqDto implementFindSubTargetCycleComReqDto = new ImplementFindSubTargetCycleComReqDto();
            if (reqDto != null) {
                implementFindSubTargetCycleComReqDto.setStandardDataCalcCycleModel(reqDto.getStandardDataCalcCycleModel());//SimpleFieldAssign//sourceId:1049790_1_45870
                implementFindSubTargetCycleComReqDto.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1049791_1_45870
                implementFindSubTargetCycleComReqDto.setCycleId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:1049792_1_45870
                implementFindSubTargetCycleComReqDto.setUpdateCycleId(reqDto.getUpdateCycleId());//SimpleFieldAssign//sourceId:1049793_1_45870
                implementFindSubTargetCycleComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1049794_1_45870
            }

            /*D3-执行获取目标内容子周期(公共)[7120]   */

            implementFindSubTargetCycleComRespDto = implementFindSubTargetCycleCom(implementFindSubTargetCycleComReqDto)/*vcase invoke 同服务,同domain*/;


            QueryStandardDataDetailComRespDto queryStandardDataDetailComRespDto = null;
            if (implementFindSubTargetCycleComRespDto != null) {
                QueryStandardDataDetailComReqDto queryStandardDataDetailComReqDto = new QueryStandardDataDetailComReqDto();
                queryStandardDataDetailComReqDto.setDataUsageSceneCode("TARGET_PLAN_CALC_DATA_STATISTICS");//sourceId:1077349_1_45871
                queryStandardDataDetailComReqDto.setIsNewData("TRUE");//sourceId:1031012_1_45871
                if (implementFindSubTargetCycleComRespDto != null) {
                    queryStandardDataDetailComReqDto.setEntityId(implementFindSubTargetCycleComRespDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1031009_1_45871
                }
                if (reqDto != null) {
                    queryStandardDataDetailComReqDto.setPeriodId(reqDto.getUpdateCycleId());//SimpleFieldAssign//sourceId:1031007_1_45871
                    queryStandardDataDetailComReqDto.setDataType(reqDto.getDataType());//SimpleFieldAssign//sourceId:1031010_1_45871
                    queryStandardDataDetailComReqDto.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1031013_1_45871
                }

                /*D4-1查标准数据详情(公共)[2695]   */
                Assert.isNull(queryStandardDataDetailComReqDto.getEntityId(), "D3-分析最新可循环周期标准数据(公共)-D4-1查标准数据详情(公共)-归属内容表主键ID不能为空", false);
                Assert.isNull(queryStandardDataDetailComReqDto.getPeriodId(), "D3-分析最新可循环周期标准数据(公共)-D4-1查标准数据详情(公共)-周期ID不能为空", false);
                Assert.isNull(queryStandardDataDetailComReqDto.getDataType(), "D3-分析最新可循环周期标准数据(公共)-D4-1查标准数据详情(公共)-数据点类型不能为空", false);
                Assert.isNull(queryStandardDataDetailComReqDto.getDataUsageSceneCode(), "D3-分析最新可循环周期标准数据(公共)-D4-1查标准数据详情(公共)-数据业务场景不能为空", false);
                Assert.isNull(queryStandardDataDetailComReqDto.getIsNewData(), "D3-分析最新可循环周期标准数据(公共)-D4-1查标准数据详情(公共)-是否归属周期最新数据不能为空", false);
                Assert.isNull(queryStandardDataDetailComReqDto.getThemeContentId(), "D3-分析最新可循环周期标准数据(公共)-D4-1查标准数据详情(公共)-主题内容ID不能为空", false);
                queryStandardDataDetailComRespDto = fwCalcStandardDataClient.queryStandardDataDetailCom(queryStandardDataDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


            }
//ModelCode: receptionService
            CalculateAcceptAboveFieldsRespDto receptionServiceRes = null;
            if (queryStandardDataDetailComRespDto != null) {
                CalculateAcceptAboveFieldsReqDto receptionServiceReq = new CalculateAcceptAboveFieldsReqDto();
                if (queryStandardDataDetailComRespDto != null) {
                    receptionServiceReq.setDataResultId(queryStandardDataDetailComRespDto.getDataResultId());//SimpleFieldAssign//sourceId:1030985_1_45872
                }

                /*约定出参：数据结果ID[6495]  用于特殊方法接收上游入参。 */

                receptionServiceRes = nbGridCalculate.calculateAcceptAboveFields(receptionServiceReq);


                receptionServiceRes_1 = receptionServiceRes;
            }
        } else if ((implementStringEfficiencyCheckComRespDto != null && implementStringEfficiencyCheckComRespDto.getStringEfficiencyCheckResult() != null && implementStringEfficiencyCheckComRespDto.getStringEfficiencyCheckResult().equals("TRUE"))) {
            //elseif(D2-判断更新周期ID是否等于归属周期ID.字符串对比结果 等于 是)  45060

            ImplementNextCyclePeriodStandardDataComRespDto implementNextCyclePeriodStandardDataComRespDto = null;
            ImplementNextCyclePeriodStandardDataComReqDto implementNextCyclePeriodStandardDataComReqDto = new ImplementNextCyclePeriodStandardDataComReqDto();
            if (reqDto != null) {
                implementNextCyclePeriodStandardDataComReqDto.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1030737_1_45063
                implementNextCyclePeriodStandardDataComReqDto.setCycleId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:1030738_1_45063
                implementNextCyclePeriodStandardDataComReqDto.setUpdateCycleId(reqDto.getUpdateCycleId());//SimpleFieldAssign//sourceId:1085671_1_45063
                implementNextCyclePeriodStandardDataComReqDto.setLastCycleType(reqDto.getLastCycleType());//SimpleFieldAssign//sourceId:1030739_1_45063
                implementNextCyclePeriodStandardDataComReqDto.setDataType(reqDto.getDataType());//SimpleFieldAssign//sourceId:1030741_1_45063
                implementNextCyclePeriodStandardDataComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1030740_1_45063
            }

            /*D4-执行最近可循环周期标准数据分析(公共)[6207]   */
            Assert.isNull(implementNextCyclePeriodStandardDataComReqDto.getEvaObjTargetCycleId(), "D3-分析最新可循环周期标准数据(公共)-D4-执行最近可循环周期标准数据分析(公共)-被评对象目标周期ID不能为空", false);
            Assert.isNull(implementNextCyclePeriodStandardDataComReqDto.getCycleId(), "D3-分析最新可循环周期标准数据(公共)-D4-执行最近可循环周期标准数据分析(公共)-周期ID不能为空", false);
            Assert.isNull(implementNextCyclePeriodStandardDataComReqDto.getLastCycleType(), "D3-分析最新可循环周期标准数据(公共)-D4-执行最近可循环周期标准数据分析(公共)-末级周期类型不能为空", false);
            Assert.isNull(implementNextCyclePeriodStandardDataComReqDto.getDataType(), "D3-分析最新可循环周期标准数据(公共)-D4-执行最近可循环周期标准数据分析(公共)-数据点类型不能为空", false);
            Assert.isNull(implementNextCyclePeriodStandardDataComReqDto.getEvaluationTemplateId(), "D3-分析最新可循环周期标准数据(公共)-D4-执行最近可循环周期标准数据分析(公共)-冗余评价模板ID不能为空", false);
            implementNextCyclePeriodStandardDataComRespDto = fwCalcStandardDataClient.implementNextCyclePeriodStandardDataCom(implementNextCyclePeriodStandardDataComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


            CalculateNewestOfMultipleNumServiceComRespDto calculateNewestOfMultipleNumServiceComRespDto = null;
            if (implementNextCyclePeriodStandardDataComRespDto != null) {
                CalculateNewestOfMultipleNumServiceComReqDto calculateNewestOfMultipleNumServiceComReqDto = new CalculateNewestOfMultipleNumServiceComReqDto();
                if (reqDto != null) {
                    calculateNewestOfMultipleNumServiceComReqDto.setDecimalPointRules(reqDto.getDecimalPointRules());//SimpleFieldAssign//sourceId:1030996_1_45067
                    calculateNewestOfMultipleNumServiceComReqDto.setDecimalDigitsLastRules(reqDto.getDecimalDigitsLastRules());//SimpleFieldAssign//sourceId:1030997_1_45067
                }
                if (implementNextCyclePeriodStandardDataComRespDto != null && implementNextCyclePeriodStandardDataComRespDto.getStandardDataList() != null && !CollectionUtil.isEmpty(implementNextCyclePeriodStandardDataComRespDto.getStandardDataList())) {
                    calculateNewestOfMultipleNumServiceComReqDto.setNewestOfMultipleNumList(//objList-to-objLists
                            implementNextCyclePeriodStandardDataComRespDto.getStandardDataList().stream().map(item -> {
                                NewestOfMultipleNumDto elm = new NewestOfMultipleNumDto();
                                if (item != null) {
                                    elm.setCommPrimaryKey(item.getDataResultId());//SimpleFieldAssign//sourceId:219220_2_45067
                                    elm.setCalcPara1(item.getDataResult());//SimpleFieldAssign//sourceId:219222_2_45067
                                    elm.setComTimeField(item.getReleaseTime());//SimpleFieldAssign//sourceId:219221_2_45067
                                }
                                return elm;
                            }).collect(Collectors.toList()));//objList-to-objLists//sourceId:1030994_1_45067
                }

                /*D4-计算数据集取最新服务(公共)[3430]   */

                calculateNewestOfMultipleNumServiceComRespDto = fwCalcCalculationRulesClient.calculateNewestOfMultipleNumServiceCom(calculateNewestOfMultipleNumServiceComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


            }
//ModelCode: receptionService
            CalculateAcceptAboveFieldsRespDto receptionServiceRes_2 = null;
            if (calculateNewestOfMultipleNumServiceComRespDto != null) {
                CalculateAcceptAboveFieldsReqDto receptionServiceReq_1 = new CalculateAcceptAboveFieldsReqDto();
                if (calculateNewestOfMultipleNumServiceComRespDto != null) {
                    receptionServiceReq_1.setDataResultId(calculateNewestOfMultipleNumServiceComRespDto.getCommPrimaryKey());//SimpleFieldAssign//sourceId:1030985_1_45068
                }

                /*约定出参：数据结果ID[6495]  用于特殊方法接收上游入参。 */

                receptionServiceRes_2 = nbGridCalculate.calculateAcceptAboveFields(receptionServiceReq_1);


                receptionServiceRes_1 = receptionServiceRes_2;
            }
        }
        ImplementAnalysisCurrentCycleIsUpdateCycleComRespDto retData = new ImplementAnalysisCurrentCycleIsUpdateCycleComRespDto();
        if (receptionServiceRes_1 != null) {
            retData.setDataResultId(receptionServiceRes_1.getDataResultId());//SimpleFieldAssign//sourceId:1031015_1
        }


        return retData;
    }

    /**
     * D3-根据是否自定义汇报分析目标内容ID(公共)[7188]
     * gen by moon at 6/11/2023, 6:43:46 AM
     */
    @Trace(operationName = "D3-根据是否自定义汇报分析目标内容ID(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementGetTargetContentIdComRespDto implementGetTargetContentIdCom(ImplementGetTargetContentIdComReqDto reqDto) {


        CalculateAcceptAboveFieldsRespDto receptionServiceRes_1 = null;
//virtualUsage 3-2-02查评价模板详情  45120
        OmsEvaluationTemplate omsEvaluationTemplate = null;
        QueryEvaTempDetailReq queryEvaTempDetailReq = new QueryEvaTempDetailReq();
        queryEvaTempDetailReq.setIsArchive("FALSE");//sourceId:1033435_1_45120
        if (reqDto != null) {
            queryEvaTempDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1033434_1_45120
        }

        /*3-2-02查评价模板详情[2316]   */
        Assert.isNull(queryEvaTempDetailReq.getEvaluationTemplateId(), "D3-根据是否自定义汇报分析目标内容ID(公共)-3-2-02查评价模板详情-评价模板ID不能为空", false);
        Assert.isNull(queryEvaTempDetailReq.getIsArchive(), "D3-根据是否自定义汇报分析目标内容ID(公共)-3-2-02查评价模板详情-是否存档不能为空", false);
        omsEvaluationTemplate = mOmsEvaluationTemplateService.queryEvaTempDetail(queryEvaTempDetailReq)/*vcase invoke 本地 method 方法调用;*/;


        if ((reqDto != null && reqDto.getTargetCycleContentTypeCode() != null && reqDto.getTargetCycleContentTypeCode().equals("TARGET"))) {
            //if(D3-根据是否自定义汇报分析目标内容ID(公共).关联目标内容类型编码 等于 目标)  45101

//ModelCode: receptionService
            CalculateAcceptAboveFieldsRespDto receptionServiceRes = null;
            if (omsEvaluationTemplate != null) {
                CalculateAcceptAboveFieldsReqDto receptionServiceReq = new CalculateAcceptAboveFieldsReqDto();
                if (omsEvaluationTemplate != null) {
                    receptionServiceReq.setTargetCycleContentId(omsEvaluationTemplate.getTargetId());//SimpleFieldAssign//sourceId:1032986_1_45109
                }

                /*约定出参：目标内容&目标内容ID[6495]  用于特殊方法接收上游入参。 */
                Assert.isNull(receptionServiceReq.getTargetCycleContentId(), "D3-根据是否自定义汇报分析目标内容ID(公共)-约定出参：目标内容&目标内容ID-关联目标内容ID不能为空", false);
                receptionServiceRes = nbGridCalculate.calculateAcceptAboveFields(receptionServiceReq);


                receptionServiceRes_1 = receptionServiceRes;
            }
        } else if ((reqDto != null && reqDto.getTargetCycleContentTypeCode() != null && reqDto.getTargetCycleContentTypeCode().equals("TARGET_CATEGORY"))) {
            //elseif(D3-根据是否自定义汇报分析目标内容ID(公共).关联目标内容类型编码 等于 目标分类)  45102

            OmsTargetCategoryExtend omsTargetCategoryExtend = null;
            QueryTargetCatExSetDetailReq queryTargetCatExSetDetailReq = new QueryTargetCatExSetDetailReq();
            queryTargetCatExSetDetailReq.setIsArchive("FALSE");//sourceId:1033114_1_45107
            if (reqDto != null) {
                queryTargetCatExSetDetailReq.setTargetCategoryId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1033104_1_45107
                queryTargetCatExSetDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1033113_1_45107
            }

            /*3-3-02-01查询目标分类扩展设置详情[3294]   */
            Assert.isNull(queryTargetCatExSetDetailReq.getTargetCategoryId(), "D3-根据是否自定义汇报分析目标内容ID(公共)-3-3-02-01查询目标分类扩展设置详情-归属目标分类ID不能为空", false);
            Assert.isNull(queryTargetCatExSetDetailReq.getEvaluationTemplateId(), "D3-根据是否自定义汇报分析目标内容ID(公共)-3-3-02-01查询目标分类扩展设置详情-冗余评价模板ID不能为空", false);
            Assert.isNull(queryTargetCatExSetDetailReq.getIsArchive(), "D3-根据是否自定义汇报分析目标内容ID(公共)-3-3-02-01查询目标分类扩展设置详情-是否存档不能为空", false);
            omsTargetCategoryExtend = mOmsTargetCategoryExtendService.queryTargetCatExSetDetail(queryTargetCatExSetDetailReq)/*vcase invoke 本地 method 方法调用;*/;


            if ((omsTargetCategoryExtend != null && omsTargetCategoryExtend.getIsOpenCustomReport() != null && omsTargetCategoryExtend.getIsOpenCustomReport().equals("TRUE") || omsTargetCategoryExtend != null && omsTargetCategoryExtend.getIsOpenCustomExecuteCycle() != null && omsTargetCategoryExtend.getIsOpenCustomExecuteCycle().equals("TRUE"))) {
                //if((3-3-02-01查目标分类是否自定义汇报或自定义执行周期.是否开启自定义汇报 等于 是 or 3-3-02-01查目标分类是否自定义汇报或自定义执行周期.是否开启自定义执行周期 等于 是))  45110

//ModelCode: receptionService
                CalculateAcceptAboveFieldsRespDto receptionServiceRes_2 = null;
                CalculateAcceptAboveFieldsReqDto receptionServiceReq_1 = new CalculateAcceptAboveFieldsReqDto();
                if (reqDto != null) {
                    receptionServiceReq_1.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1032986_1_45111
                }

                /*约定出参：目标内容&目标内容ID[6495]  用于特殊方法接收上游入参。 */
                Assert.isNull(receptionServiceReq_1.getTargetCycleContentId(), "D3-根据是否自定义汇报分析目标内容ID(公共)-约定出参：目标内容&目标内容ID-关联目标内容ID不能为空", false);
                receptionServiceRes_2 = nbGridCalculate.calculateAcceptAboveFields(receptionServiceReq_1);


                receptionServiceRes_1 = receptionServiceRes_2;
            } else if ((omsTargetCategoryExtend != null && omsTargetCategoryExtend.getIsOpenCustomReport() != null && omsTargetCategoryExtend.getIsOpenCustomReport().equals("FALSE") && omsTargetCategoryExtend != null && omsTargetCategoryExtend.getIsOpenCustomExecuteCycle() != null && omsTargetCategoryExtend.getIsOpenCustomExecuteCycle().equals("FALSE"))) {
                //elseif((3-3-02-01查目标分类是否自定义汇报或自定义执行周期.是否开启自定义汇报 等于 否 and 3-3-02-01查目标分类是否自定义汇报或自定义执行周期.是否开启自定义执行周期 等于 否))  45112

//ModelCode: receptionService
                CalculateAcceptAboveFieldsRespDto receptionServiceRes_3 = null;
                if (omsEvaluationTemplate != null) {
                    CalculateAcceptAboveFieldsReqDto receptionServiceReq_2 = new CalculateAcceptAboveFieldsReqDto();
                    if (omsEvaluationTemplate != null) {
                        receptionServiceReq_2.setTargetCycleContentId(omsEvaluationTemplate.getTargetId());//SimpleFieldAssign//sourceId:1032986_1_45114
                    }

                    /*约定出参：目标内容&目标内容ID[6495]  用于特殊方法接收上游入参。 */
                    Assert.isNull(receptionServiceReq_2.getTargetCycleContentId(), "D3-根据是否自定义汇报分析目标内容ID(公共)-约定出参：目标内容&目标内容ID-关联目标内容ID不能为空", false);
                    receptionServiceRes_3 = nbGridCalculate.calculateAcceptAboveFields(receptionServiceReq_2);


                    receptionServiceRes_1 = receptionServiceRes_3;
                }
            }
        } else if ((reqDto != null && reqDto.getTargetCycleContentTypeCode() != null && reqDto.getTargetCycleContentTypeCode().equals("OBJECTIVE"))) {
            //elseif(D3-根据是否自定义汇报分析目标内容ID(公共).关联目标内容类型编码 等于 指标)  45103

            OmsTargetObjectivePlanExtend omsTargetObjectivePlanExtend = null;
            QueryTargetObjPlanExDetailReq queryTargetObjPlanExDetailReq = new QueryTargetObjPlanExDetailReq();
            queryTargetObjPlanExDetailReq.setIsArchive("FALSE");//sourceId:1033130_1_45108
            if (reqDto != null) {
                queryTargetObjPlanExDetailReq.setObjectiveId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1033117_1_45108
                queryTargetObjPlanExDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1033138_1_45108
            }

            /*3-3-05查指标扩展规划设置详情[2725]   */
            Assert.isNull(queryTargetObjPlanExDetailReq.getObjectiveId(), "D3-根据是否自定义汇报分析目标内容ID(公共)-3-3-05查指标扩展规划设置详情-归属指标ID不能为空", false);
            Assert.isNull(queryTargetObjPlanExDetailReq.getEvaluationTemplateId(), "D3-根据是否自定义汇报分析目标内容ID(公共)-3-3-05查指标扩展规划设置详情-冗余评价模板ID不能为空", false);
            Assert.isNull(queryTargetObjPlanExDetailReq.getIsArchive(), "D3-根据是否自定义汇报分析目标内容ID(公共)-3-3-05查指标扩展规划设置详情-是否存档不能为空", false);
            omsTargetObjectivePlanExtend = mOmsTargetObjectivePlanExtendService.queryTargetObjPlanExDetail(queryTargetObjPlanExDetailReq)/*vcase invoke 本地 method 方法调用;*/;


            if ((omsTargetObjectivePlanExtend != null && omsTargetObjectivePlanExtend.getIsOpenCustomReport() != null && omsTargetObjectivePlanExtend.getIsOpenCustomReport().equals("TRUE") || omsTargetObjectivePlanExtend != null && omsTargetObjectivePlanExtend.getIsOpenCustomExecuteCycle() != null && omsTargetObjectivePlanExtend.getIsOpenCustomExecuteCycle().equals("TRUE"))) {
                //if((3-3-05查指标是否自定义汇报或自定义执行周期.是否开启自定义汇报 等于 是 or 3-3-05查指标是否自定义汇报或自定义执行周期.是否开启自定义执行周期 等于 是))  45115

//ModelCode: receptionService
                CalculateAcceptAboveFieldsRespDto receptionServiceRes_4 = null;
                CalculateAcceptAboveFieldsReqDto receptionServiceReq_3 = new CalculateAcceptAboveFieldsReqDto();
                if (reqDto != null) {
                    receptionServiceReq_3.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1032986_1_45116
                }

                /*约定出参：目标内容&目标内容ID[6495]  用于特殊方法接收上游入参。 */
                Assert.isNull(receptionServiceReq_3.getTargetCycleContentId(), "D3-根据是否自定义汇报分析目标内容ID(公共)-约定出参：目标内容&目标内容ID-关联目标内容ID不能为空", false);
                receptionServiceRes_4 = nbGridCalculate.calculateAcceptAboveFields(receptionServiceReq_3);


                receptionServiceRes_1 = receptionServiceRes_4;
            } else if ((omsTargetObjectivePlanExtend != null && omsTargetObjectivePlanExtend.getIsOpenCustomReport() != null && omsTargetObjectivePlanExtend.getIsOpenCustomReport().equals("FALSE") && omsTargetObjectivePlanExtend != null && omsTargetObjectivePlanExtend.getIsOpenCustomExecuteCycle() != null && omsTargetObjectivePlanExtend.getIsOpenCustomExecuteCycle().equals("FALSE"))) {
                //elseif((3-3-05查指标是否自定义汇报或自定义执行周期.是否开启自定义汇报 等于 否 and 3-3-05查指标是否自定义汇报或自定义执行周期.是否开启自定义执行周期 等于 否))  45117

//ModelCode: receptionService
                CalculateAcceptAboveFieldsRespDto receptionServiceRes_5 = null;
                if (omsEvaluationTemplate != null) {
                    CalculateAcceptAboveFieldsReqDto receptionServiceReq_4 = new CalculateAcceptAboveFieldsReqDto();
                    if (omsEvaluationTemplate != null) {
                        receptionServiceReq_4.setTargetCycleContentId(omsEvaluationTemplate.getTargetId());//SimpleFieldAssign//sourceId:1032986_1_45118
                    }

                    /*约定出参：目标内容&目标内容ID[6495]  用于特殊方法接收上游入参。 */
                    Assert.isNull(receptionServiceReq_4.getTargetCycleContentId(), "D3-根据是否自定义汇报分析目标内容ID(公共)-约定出参：目标内容&目标内容ID-关联目标内容ID不能为空", false);
                    receptionServiceRes_5 = nbGridCalculate.calculateAcceptAboveFields(receptionServiceReq_4);


                    receptionServiceRes_1 = receptionServiceRes_5;
                }
            }
        }
        ImplementGetTargetContentIdComRespDto retData = new ImplementGetTargetContentIdComRespDto();
        if (receptionServiceRes_1 != null) {
            retData.setTargetCycleContentId(receptionServiceRes_1.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1033396_1
        }


        return retData;
    }

    /**
     * D3-新增托底网格计算调度(公共)[7215]
     * gen by moon at 6/20/2023, 6:20:32 PM
     */
    @Trace(operationName = "D3-新增托底网格计算调度(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public AddUnderpinningCalcGridDispatchComRespDto addUnderpinningCalcGridDispatchCom(AddUnderpinningCalcGridDispatchComReqDto reqDto) {


        ImplementAcceptFieldRespDto receptionServiceRes_1 = null;
//virtualUsage D3获取执行进度信息(公共)  45554
        ObtainStatisticsUpdateExecuteProgressComRespDto obtainExecuteProgressComRespDto = null;
        ObtainStatisticsUpdateExecuteProgressComReqDto obtainExecuteProgressComReqDto = new ObtainStatisticsUpdateExecuteProgressComReqDto();
        obtainExecuteProgressComReqDto.setObjectTypeCode("OMS_EVALUATION_TEMPLATE");//sourceId:1042708_1_45554
        obtainExecuteProgressComReqDto.setUseTypeCode("USE_ALL_TEMP_CALCULATE");//CUSTOM_CONVENTION//sourceId:1042710_1_45554
        obtainExecuteProgressComReqDto.setThemeContentTypeCode("OMS_EVALUATION_TEMPLATE");//sourceId:1042716_1_45554
        obtainExecuteProgressComReqDto.setOperationInductionId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecInductionRecordId());//CURRENT_INDUCTIONID//sourceId:1042712_1_45554
        obtainExecuteProgressComReqDto.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:1042714_1_45554
        obtainExecuteProgressComReqDto.setAppId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecAppId());//CURRENT_APPID//sourceId:1042715_1_45554
        if (reqDto != null) {
            obtainExecuteProgressComReqDto.setObjectId(reqDto.getThemeContentId());//SimpleFieldAssign//sourceId:1042709_1_45554
            obtainExecuteProgressComReqDto.setThemeContentId(reqDto.getThemeContentId());//SimpleFieldAssign//sourceId:1042711_1_45554
        }

        /*D3获取执行进度信息(公共)[7207]   */
        Assert.isNull(obtainExecuteProgressComReqDto.getObjectTypeCode(), "D3-新增托底网格计算调度(公共)-D3获取执行进度信息(公共)-归属对象类型编码不能为空", false);
        Assert.isNull(obtainExecuteProgressComReqDto.getObjectId(), "D3-新增托底网格计算调度(公共)-D3获取执行进度信息(公共)-归属对象内容ID不能为空", false);
        Assert.isNull(obtainExecuteProgressComReqDto.getUseTypeCode(), "D3-新增托底网格计算调度(公共)-D3获取执行进度信息(公共)-用途类型编码不能为空", false);
        Assert.isNull(obtainExecuteProgressComReqDto.getThemeContentTypeCode(), "D3-新增托底网格计算调度(公共)-D3获取执行进度信息(公共)-主题内容类型编码不能为空", false);
        Assert.isNull(obtainExecuteProgressComReqDto.getThemeContentId(), "D3-新增托底网格计算调度(公共)-D3获取执行进度信息(公共)-主题内容ID不能为空", false);
        Assert.isNull(obtainExecuteProgressComReqDto.getOperationInductionId(), "D3-新增托底网格计算调度(公共)-D3获取执行进度信息(公共)-操作人就职记录ID不能为空", false);
        Assert.isNull(obtainExecuteProgressComReqDto.getSpaceId(), "D3-新增托底网格计算调度(公共)-D3获取执行进度信息(公共)-创建于空间ID不能为空", false);
        Assert.isNull(obtainExecuteProgressComReqDto.getAppId(), "D3-新增托底网格计算调度(公共)-D3获取执行进度信息(公共)-创建于联盟应用ID不能为空", false);
        obtainExecuteProgressComRespDto = executeProgressService.obtainStatisticsUpdateExecuteProgressCom(obtainExecuteProgressComReqDto)/*vcase invoke isSameApp*/;


//virtualUsage 3-2-09查未完成的全网格计算标准数据调度是否存在  45538
        OmsTargetTimingTaskDispatch omsTargetTimingTaskDispatch = null;
        QueryTimerTaskPlanDetailReq queryTimerTaskPlanDetailReq = new QueryTimerTaskPlanDetailReq();
        queryTimerTaskPlanDetailReq.setTaskDispatchTypeCode("CONTENT_SUBTASK");//sourceId:1041769_1_45538
        queryTimerTaskPlanDetailReq.setDispatchActionTypeCode("DISPATCH_EXECUTE_GRID_CALC_TASK");//sourceId:1041770_1_45538
        queryTimerTaskPlanDetailReq.setIsComplete("FALSE");//sourceId:1041773_1_45538
        queryTimerTaskPlanDetailReq.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:1041774_1_45538
        if (reqDto != null) {
            queryTimerTaskPlanDetailReq.setObjectId(reqDto.getTargetId());//SimpleFieldAssign//sourceId:1041771_1_45538
            queryTimerTaskPlanDetailReq.setThemeContentId(reqDto.getThemeContentId());//SimpleFieldAssign//sourceId:1041772_1_45538
        }

        /*3-2-09查未完成的全网格计算标准数据调度是否存在[3187]   */
        Assert.isNull(queryTimerTaskPlanDetailReq.getTaskDispatchTypeCode(), "D3-新增托底网格计算调度(公共)-3-2-09查未完成的全网格计算标准数据调度是否存在-任务调度类型编码不能为空", false);
        Assert.isNull(queryTimerTaskPlanDetailReq.getDispatchActionTypeCode(), "D3-新增托底网格计算调度(公共)-3-2-09查未完成的全网格计算标准数据调度是否存在-任务调度的行为类型编码不能为空", false);
        Assert.isNull(queryTimerTaskPlanDetailReq.getObjectId(), "D3-新增托底网格计算调度(公共)-3-2-09查未完成的全网格计算标准数据调度是否存在-归属对象内容ID不能为空", false);
        Assert.isNull(queryTimerTaskPlanDetailReq.getThemeContentId(), "D3-新增托底网格计算调度(公共)-3-2-09查未完成的全网格计算标准数据调度是否存在-主题内容ID不能为空", false);
        Assert.isNull(queryTimerTaskPlanDetailReq.getIsComplete(), "D3-新增托底网格计算调度(公共)-3-2-09查未完成的全网格计算标准数据调度是否存在-是否执行完成不能为空", false);
        Assert.isNull(queryTimerTaskPlanDetailReq.getSpaceId(), "D3-新增托底网格计算调度(公共)-3-2-09查未完成的全网格计算标准数据调度是否存在-创建于空间ID不能为空", false);
        omsTargetTimingTaskDispatch = mOmsTargetTimingTaskDispatchService.queryTimerTaskPlanDetail(queryTimerTaskPlanDetailReq)/*vcase invoke 本地 method 方法调用;*/;


        if ((omsTargetTimingTaskDispatch == null || !(obtainExecuteProgressComRespDto != null && obtainExecuteProgressComRespDto.getAsyncExecuteState() != null && obtainExecuteProgressComRespDto.getAsyncExecuteState().equals("IN_PROGRESS")))) {
            //if((3-2-09查未完成的全网格计算标准数据调度是否存在.出参 值等于空  or D3获取执行进度信息(公共).异步执行状态 不等于 进行中))  45539

            OmsEvaluationTemplate omsEvaluationTemplate = null;
            QueryEvaTempDetailReq queryEvaTempDetailReq = new QueryEvaTempDetailReq();
            queryEvaTempDetailReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1041895_1_45541
            if (reqDto != null) {
                queryEvaTempDetailReq.setEvaluationTemplateId(reqDto.getThemeContentId());//SimpleFieldAssign//sourceId:1041894_1_45541
                queryEvaTempDetailReq.setTargetId(reqDto.getTargetId());//SimpleFieldAssign//sourceId:1041922_1_45541
            }

            /*3-2-02查评价模板简称[2316]   */
            Assert.isNull(queryEvaTempDetailReq.getEvaluationTemplateId(), "D3-新增托底网格计算调度(公共)-3-2-02查评价模板简称-评价模板ID不能为空", false);
            Assert.isNull(queryEvaTempDetailReq.getTargetId(), "D3-新增托底网格计算调度(公共)-3-2-02查评价模板简称-对应的目标ID不能为空", false);
            Assert.isNull(queryEvaTempDetailReq.getSubjectLifeCycle(), "D3-新增托底网格计算调度(公共)-3-2-02查评价模板简称-主体生命周期不能为空", false);
            omsEvaluationTemplate = mOmsEvaluationTemplateService.queryEvaTempDetail(queryEvaTempDetailReq)/*vcase invoke 本地 method 方法调用;*/;


            OmsCycle omsCycle = null;
            QueryCycleDetailReq queryCycleDetailReq = new QueryCycleDetailReq();
            queryCycleDetailReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1041953_1_45542
            if (reqDto != null) {
                queryCycleDetailReq.setCycleId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:1041952_1_45542
            }

            /*3-4-04查周期名称[2004]   */
            Assert.isNull(queryCycleDetailReq.getCycleId(), "D3-新增托底网格计算调度(公共)-3-4-04查周期名称-周期ID不能为空", false);
            Assert.isNull(queryCycleDetailReq.getSubjectLifeCycle(), "D3-新增托底网格计算调度(公共)-3-4-04查周期名称-主体生命周期不能为空", false);
            omsCycle = mOmsCycleService.queryCycleDetail(queryCycleDetailReq)/*vcase invoke 本地 method 方法调用;*/;


            AddTimerTaskPlanComRespDto addTimerTaskPlanComRespDto = null;
            if (omsCycle != null && omsEvaluationTemplate != null && obtainExecuteProgressComRespDto != null) {
                AddTimerTaskPlanComReqDto addTimerTaskPlanComReqDto = new AddTimerTaskPlanComReqDto();
                addTimerTaskPlanComReqDto.setIsCompensateTask("FALSE");//sourceId:1041776_1_45540
                addTimerTaskPlanComReqDto.setDispatchActionTypeCode("DISPATCH_EXECUTE_GRID_CALC_TASK");//sourceId:1041777_1_45540
                addTimerTaskPlanComReqDto.setTaskDispatchTypeCode("CONTENT_SUBTASK");//sourceId:1041778_1_45540
                addTimerTaskPlanComReqDto.setObjectTypeCode("OMS_TARGET");//sourceId:1041779_1_45540
                addTimerTaskPlanComReqDto.setAddRuleInfoTypeCode("OMS_CYCLE");//sourceId:1041782_1_45540
                addTimerTaskPlanComReqDto.setThemeContentTypeCode("OMS_EVALUATION_TEMPLATE");//sourceId:1041796_1_45540
                addTimerTaskPlanComReqDto.setIsAppointSimpleMq("FALSE");//sourceId:1041793_1_45540
                addTimerTaskPlanComReqDto.setIsComplete("FALSE");//sourceId:1041791_1_45540
                addTimerTaskPlanComReqDto.setIsRealTimeaSync("TRUE");//sourceId:1041802_1_45540
                addTimerTaskPlanComReqDto.setOperationInductionId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecInductionRecordId());//CURRENT_INDUCTIONID//sourceId:1041788_1_45540
                addTimerTaskPlanComReqDto.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:1041789_1_45540
                addTimerTaskPlanComReqDto.setAppId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecAppId());//CURRENT_APPID//sourceId:1041790_1_45540
                if (omsCycle != null) {
                    addTimerTaskPlanComReqDto.setCycleStandardName(omsCycle.getCycleStandardName());//SimpleFieldAssign//sourceId:1041957_1_45540
                }
                if (omsEvaluationTemplate != null) {
                    addTimerTaskPlanComReqDto.setTargetContentName(omsEvaluationTemplate.getEvaluationTempShortName());//SimpleFieldAssign//sourceId:1041956_1_45540
                }
                if (reqDto != null) {
                    addTimerTaskPlanComReqDto.setObjectId(reqDto.getTargetId());//SimpleFieldAssign//sourceId:1041780_1_45540
                    addTimerTaskPlanComReqDto.setAddRuleInfoId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:1041783_1_45540
                    addTimerTaskPlanComReqDto.setThemeContentId(reqDto.getThemeContentId());//SimpleFieldAssign//sourceId:1041797_1_45540
                    addTimerTaskPlanComReqDto.setStandbyField1(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1041781_1_45540
                }
                if (obtainExecuteProgressComRespDto != null) {
                    addTimerTaskPlanComReqDto.setStandbyField2(obtainExecuteProgressComRespDto.getExecuteProgressId());//SimpleFieldAssign//sourceId:1041798_1_45540
                }

                /*D3新增定时任务调度(公共)[4995]   */
                Assert.isNull(addTimerTaskPlanComReqDto.getCycleStandardName(), "D3-新增托底网格计算调度(公共)-D3新增定时任务调度(公共)-周期名称不能为空", false);
                Assert.isNull(addTimerTaskPlanComReqDto.getTargetContentName(), "D3-新增托底网格计算调度(公共)-D3新增定时任务调度(公共)-目标内容名称不能为空", false);
                Assert.isNull(addTimerTaskPlanComReqDto.getIsCompensateTask(), "D3-新增托底网格计算调度(公共)-D3新增定时任务调度(公共)-是否补偿任务不能为空", false);
                Assert.isNull(addTimerTaskPlanComReqDto.getDispatchActionTypeCode(), "D3-新增托底网格计算调度(公共)-D3新增定时任务调度(公共)-任务调度的行为类型编码不能为空", false);
                Assert.isNull(addTimerTaskPlanComReqDto.getTaskDispatchTypeCode(), "D3-新增托底网格计算调度(公共)-D3新增定时任务调度(公共)-任务调度类型编码不能为空", false);
                Assert.isNull(addTimerTaskPlanComReqDto.getObjectTypeCode(), "D3-新增托底网格计算调度(公共)-D3新增定时任务调度(公共)-归属对象类型编码不能为空", false);
                Assert.isNull(addTimerTaskPlanComReqDto.getObjectId(), "D3-新增托底网格计算调度(公共)-D3新增定时任务调度(公共)-归属对象内容ID不能为空", false);
                Assert.isNull(addTimerTaskPlanComReqDto.getAddRuleInfoTypeCode(), "D3-新增托底网格计算调度(公共)-D3新增定时任务调度(公共)-生成规则信息类型编码不能为空", false);
                Assert.isNull(addTimerTaskPlanComReqDto.getAddRuleInfoId(), "D3-新增托底网格计算调度(公共)-D3新增定时任务调度(公共)-生成辅助规则信息值不能为空", false);
                Assert.isNull(addTimerTaskPlanComReqDto.getThemeContentTypeCode(), "D3-新增托底网格计算调度(公共)-D3新增定时任务调度(公共)-主题内容类型编码不能为空", false);
                Assert.isNull(addTimerTaskPlanComReqDto.getThemeContentId(), "D3-新增托底网格计算调度(公共)-D3新增定时任务调度(公共)-主题内容ID不能为空", false);
                Assert.isNull(addTimerTaskPlanComReqDto.getStandbyField1(), "D3-新增托底网格计算调度(公共)-D3新增定时任务调度(公共)-备用字段1不能为空", false);
                Assert.isNull(addTimerTaskPlanComReqDto.getStandbyField2(), "D3-新增托底网格计算调度(公共)-D3新增定时任务调度(公共)-备用字段2不能为空", false);
                Assert.isNull(addTimerTaskPlanComReqDto.getIsAppointSimpleMq(), "D3-新增托底网格计算调度(公共)-D3新增定时任务调度(公共)-是否固化消息队列不能为空", false);
                Assert.isNull(addTimerTaskPlanComReqDto.getIsComplete(), "D3-新增托底网格计算调度(公共)-D3新增定时任务调度(公共)-是否执行完成不能为空", false);
                Assert.isNull(addTimerTaskPlanComReqDto.getIsRealTimeaSync(), "D3-新增托底网格计算调度(公共)-D3新增定时任务调度(公共)-是否实时异步调度不能为空", false);
                Assert.isNull(addTimerTaskPlanComReqDto.getOperationInductionId(), "D3-新增托底网格计算调度(公共)-D3新增定时任务调度(公共)-操作人就职记录ID不能为空", false);
                Assert.isNull(addTimerTaskPlanComReqDto.getSpaceId(), "D3-新增托底网格计算调度(公共)-D3新增定时任务调度(公共)-创建于空间ID不能为空", false);
                Assert.isNull(addTimerTaskPlanComReqDto.getAppId(), "D3-新增托底网格计算调度(公共)-D3新增定时任务调度(公共)-创建于联盟应用ID不能为空", false);
                addTimerTaskPlanComRespDto = taskGenService.addTimerTaskPlanCom(addTimerTaskPlanComReqDto)/*vcase invoke isSameApp*/;


            }
//ModelCode: receptionService
            ImplementAcceptFieldRespDto receptionServiceRes = null;
            if (addTimerTaskPlanComRespDto != null) {
                ImplementAcceptFieldReqDto receptionServiceReq = new ImplementAcceptFieldReqDto();
                if (addTimerTaskPlanComRespDto != null) {
                    receptionServiceReq.setTimingTaskDispatchId(addTimerTaskPlanComRespDto.getTimingTaskDispatchId());//SimpleFieldAssign//sourceId:1042720_1_45555
                }

                /*出参字段：定时任务调度ID[6100]  用于特殊方法接收上游入参。 */
                Assert.isNull(receptionServiceReq.getTimingTaskDispatchId(), "D3-新增托底网格计算调度(公共)-出参字段：定时任务调度ID-定时任务调度记录ID不能为空", false);
                receptionServiceRes = nbGridCalculate.implementAcceptField(receptionServiceReq);


                receptionServiceRes_1 = receptionServiceRes;
            }
        } else {
            //else  45556

//ModelCode: receptionService
            ImplementAcceptFieldRespDto receptionServiceRes_2 = null;
            if (omsTargetTimingTaskDispatch != null) {
                ImplementAcceptFieldReqDto receptionServiceReq_1 = new ImplementAcceptFieldReqDto();
                if (omsTargetTimingTaskDispatch != null) {
                    receptionServiceReq_1.setTimingTaskDispatchId(omsTargetTimingTaskDispatch.getTimingTaskDispatchId());//SimpleFieldAssign//sourceId:1042720_1_45557
                }

                /*出参字段：定时任务调度ID[6100]  用于特殊方法接收上游入参。 */
                Assert.isNull(receptionServiceReq_1.getTimingTaskDispatchId(), "D3-新增托底网格计算调度(公共)-出参字段：定时任务调度ID-定时任务调度记录ID不能为空", false);
                receptionServiceRes_2 = nbGridCalculate.implementAcceptField(receptionServiceReq_1);


                receptionServiceRes_1 = receptionServiceRes_2;
            }
        }
        AddUnderpinningCalcGridDispatchComRespDto retData = new AddUnderpinningCalcGridDispatchComRespDto();
        if (receptionServiceRes_1 != null) {
            retData.setTimingTaskDispatchId(receptionServiceRes_1.getTimingTaskDispatchId());//SimpleFieldAssign//sourceId:1042721_1
        }


        return retData;
    }

    /**
     * D3-新增托底网格计算调度(公共)[7215]
     * gen by moon at 6/26/2023, 10:30:38 PM
     */
    @Trace(operationName = "D3-新增托底网格计算调度(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public AddUnderCalcGridDispatchComRespDto addUnderCalcGridDispatchCom(AddUnderCalcGridDispatchComReqDto reqDto) {


        Boolean bLock = false;
        String key = "";
        ImplementAcceptFieldRespDto receptionServiceRes_1 = null;
        try {

//virtualUsage D3获取执行进度信息(公共)  45554
            ObtainStatisticsUpdateExecuteProgressComRespDto obtainStatisticsUpdateExecuteProgressComRespDto = null;
            ObtainStatisticsUpdateExecuteProgressComReqDto obtainStatisticsUpdateExecuteProgressComReqDto = new ObtainStatisticsUpdateExecuteProgressComReqDto();
            obtainStatisticsUpdateExecuteProgressComReqDto.setObjectTypeCode("OMS_EVALUATION_TEMPLATE");//sourceId:1042708_1_45554
            obtainStatisticsUpdateExecuteProgressComReqDto.setUseTypeCode("USE_ALL_TEMP_CALCULATE");//CUSTOM_CONVENTION//sourceId:1042710_1_45554
            obtainStatisticsUpdateExecuteProgressComReqDto.setThemeContentTypeCode("OMS_EVALUATION_TEMPLATE");//sourceId:1042716_1_45554
            obtainStatisticsUpdateExecuteProgressComReqDto.setOperationInductionId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecInductionRecordId());//CURRENT_INDUCTIONID//sourceId:1042712_1_45554
            obtainStatisticsUpdateExecuteProgressComReqDto.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:1042714_1_45554
            obtainStatisticsUpdateExecuteProgressComReqDto.setAppId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecAppId());//CURRENT_APPID//sourceId:1042715_1_45554
            if (reqDto != null) {
                obtainStatisticsUpdateExecuteProgressComReqDto.setObjectId(reqDto.getThemeContentId());//SimpleFieldAssign//sourceId:1042709_1_45554
                obtainStatisticsUpdateExecuteProgressComReqDto.setThemeContentId(reqDto.getThemeContentId());//SimpleFieldAssign//sourceId:1042711_1_45554
            }

            /*D3获取执行进度信息(公共)[7207]   */
            Assert.isNull(obtainStatisticsUpdateExecuteProgressComReqDto.getObjectTypeCode(), "D3-新增托底网格计算调度(公共)-D3获取执行进度信息(公共)-归属对象类型编码不能为空", false);
            Assert.isNull(obtainStatisticsUpdateExecuteProgressComReqDto.getObjectId(), "D3-新增托底网格计算调度(公共)-D3获取执行进度信息(公共)-归属对象内容ID不能为空", false);
            Assert.isNull(obtainStatisticsUpdateExecuteProgressComReqDto.getUseTypeCode(), "D3-新增托底网格计算调度(公共)-D3获取执行进度信息(公共)-用途类型编码不能为空", false);
            Assert.isNull(obtainStatisticsUpdateExecuteProgressComReqDto.getThemeContentTypeCode(), "D3-新增托底网格计算调度(公共)-D3获取执行进度信息(公共)-主题内容类型编码不能为空", false);
            Assert.isNull(obtainStatisticsUpdateExecuteProgressComReqDto.getThemeContentId(), "D3-新增托底网格计算调度(公共)-D3获取执行进度信息(公共)-主题内容ID不能为空", false);
            Assert.isNull(obtainStatisticsUpdateExecuteProgressComReqDto.getOperationInductionId(), "D3-新增托底网格计算调度(公共)-D3获取执行进度信息(公共)-操作人就职记录ID不能为空", false);
            Assert.isNull(obtainStatisticsUpdateExecuteProgressComReqDto.getSpaceId(), "D3-新增托底网格计算调度(公共)-D3获取执行进度信息(公共)-创建于空间ID不能为空", false);
            Assert.isNull(obtainStatisticsUpdateExecuteProgressComReqDto.getAppId(), "D3-新增托底网格计算调度(公共)-D3获取执行进度信息(公共)-创建于联盟应用ID不能为空", false);
            obtainStatisticsUpdateExecuteProgressComRespDto = executeProgressService.obtainStatisticsUpdateExecuteProgressCom(obtainStatisticsUpdateExecuteProgressComReqDto)/*vcase invoke isSameApp*/;


//virtualUsage 3-2-09查询定时任务调度列表  45935
            List<OmsTargetTimingTaskDispatch> listOmsTargetTimingTaskDispatch = new ArrayList<>();
            QueryTimerTaskPlanListReq queryTimerTaskPlanListReq = new QueryTimerTaskPlanListReq();
            queryTimerTaskPlanListReq.setTaskDispatchTypeCode("CONTENT_SUBTASK");//sourceId:1053130_1_45935
            queryTimerTaskPlanListReq.setDispatchActionTypeCode("DISPATCH_EXECUTE_GRID_CALC_TASK");//sourceId:1053131_1_45935
            queryTimerTaskPlanListReq.setIsComplete("FALSE");//sourceId:1053133_1_45935
            queryTimerTaskPlanListReq.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:1053137_1_45935
            if (reqDto != null) {
                queryTimerTaskPlanListReq.setObjectId(reqDto.getThemeContentId());//SimpleFieldAssign//sourceId:1053136_1_45935
                queryTimerTaskPlanListReq.setThemeContentId(reqDto.getThemeContentId());//SimpleFieldAssign//sourceId:1053146_1_45935
            }

            /*3-2-09查询定时任务调度列表[3261]   */
            Assert.isNull(queryTimerTaskPlanListReq.getTaskDispatchTypeCode(), "D3-新增托底网格计算调度(公共)-3-2-09查询定时任务调度列表-任务调度类型编码不能为空", false);
            Assert.isNull(queryTimerTaskPlanListReq.getDispatchActionTypeCode(), "D3-新增托底网格计算调度(公共)-3-2-09查询定时任务调度列表-任务调度的行为类型编码不能为空", false);
            Assert.isNull(queryTimerTaskPlanListReq.getObjectId(), "D3-新增托底网格计算调度(公共)-3-2-09查询定时任务调度列表-归属对象内容ID不能为空", false);
            Assert.isNull(queryTimerTaskPlanListReq.getThemeContentId(), "D3-新增托底网格计算调度(公共)-3-2-09查询定时任务调度列表-主题内容ID不能为空", false);
            Assert.isNull(queryTimerTaskPlanListReq.getIsComplete(), "D3-新增托底网格计算调度(公共)-3-2-09查询定时任务调度列表-是否执行完成不能为空", false);
            Assert.isNull(queryTimerTaskPlanListReq.getSpaceId(), "D3-新增托底网格计算调度(公共)-3-2-09查询定时任务调度列表-创建于空间ID不能为空", false);
            listOmsTargetTimingTaskDispatch = mOmsTargetTimingTaskDispatchService.queryTimerTaskPlanList(queryTimerTaskPlanListReq)/*vcase invoke 本地 method 方法调用;*/;


            if ((listOmsTargetTimingTaskDispatch != null && listOmsTargetTimingTaskDispatch != null && listOmsTargetTimingTaskDispatch.size() == 0)) {
                //if(3-2-09查未完成的全网格计算标准数据调度列表.定时任务调度列表数据集条数 等于 0)  45936

                ObtainLockSemanticInstanceComRespDto obtainLockSemanticInstanceComRespDto = null;
                ObtainLockSemanticInstanceComReqDto obtainLockSemanticInstanceComReqDto = new ObtainLockSemanticInstanceComReqDto();
                obtainLockSemanticInstanceComReqDto.setTemplateSemanticEngineCode("ADD_TEMP_ALL_CONTENT_CALC_LOCK_KEY");//CUSTOM_CONVENTION//sourceId:1065135_1_46380
                if (reqDto != null) {
                    obtainLockSemanticInstanceComReqDto.setEvaluationTemplateId(reqDto.getThemeContentId());//SimpleFieldAssign//sourceId:1065137_1_46380
                }

                /*D2获取分布式锁语义实例(公共)[7255]   */
                Assert.isNull(obtainLockSemanticInstanceComReqDto.getTemplateSemanticEngineCode(), "D3-新增托底网格计算调度(公共)-D2获取分布式锁语义实例(公共)-模板引擎标识不能为空", false);
                Assert.isNull(obtainLockSemanticInstanceComReqDto.getEvaluationTemplateId(), "D3-新增托底网格计算调度(公共)-D2获取分布式锁语义实例(公共)-冗余评价模板ID不能为空", false);
                obtainLockSemanticInstanceComRespDto = fwCompTemplateEngineClient.obtainLockSemanticInstanceCom(obtainLockSemanticInstanceComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;

                key = obtainLockSemanticInstanceComRespDto.getObjectName();

                ImplementDistributedLockingComRespDto implementDistributedLockingComRespDto = null;
                if (obtainLockSemanticInstanceComRespDto != null) {
                    ImplementDistributedLockingComReqDto implementDistributedLockingComReqDto = new ImplementDistributedLockingComReqDto();
                    implementDistributedLockingComReqDto.setDuration(Long.valueOf(120));//CUSTOM_CONVENTION//sourceId:1065132_1_46375
                    if (obtainLockSemanticInstanceComRespDto != null) {
                        implementDistributedLockingComReqDto.setCommPrimaryKey(obtainLockSemanticInstanceComRespDto.getObjectName());//SimpleFieldAssign//sourceId:1065133_1_46375
                    }

                    /*D3分布式加锁(公共)[7253]   */
                    Assert.isNull(implementDistributedLockingComReqDto.getCommPrimaryKey(), "D3-新增托底网格计算调度(公共)-D3分布式加锁(公共)-通用主键ID不能为空", false);
                    Assert.isNull(implementDistributedLockingComReqDto.getDuration(), "D3-新增托底网格计算调度(公共)-D3分布式加锁(公共)-锁定时长不能为空", false);
                    implementDistributedLockingComRespDto = interfaceModeService.implementDistributedLockingCom(implementDistributedLockingComReqDto)/*vcase invoke isSameApp*/;


                }
                if ((implementDistributedLockingComRespDto != null && implementDistributedLockingComRespDto.getTureOrFalse() != null && implementDistributedLockingComRespDto.getTureOrFalse().equals("TRUE"))) {
                    //if(D3分布式加锁(公共).加锁是否成功 等于 是)  46376

                    bLock = true;
                    OmsEvaluationTemplate omsEvaluationTemplate = null;
                    QueryEvaTempDetailReq queryEvaTempDetailReq = new QueryEvaTempDetailReq();
                    queryEvaTempDetailReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1041895_1_46381
                    if (reqDto != null) {
                        queryEvaTempDetailReq.setTargetId(reqDto.getTargetId());//SimpleFieldAssign//sourceId:1041922_1_46381
                        queryEvaTempDetailReq.setEvaluationTemplateId(reqDto.getThemeContentId());//SimpleFieldAssign//sourceId:1041894_1_46381
                    }

                    /*3-2-02查评价模板简称[2316]   */
                    Assert.isNull(queryEvaTempDetailReq.getTargetId(), "D3-新增托底网格计算调度(公共)-3-2-02查评价模板简称-对应的目标ID不能为空", false);
                    Assert.isNull(queryEvaTempDetailReq.getEvaluationTemplateId(), "D3-新增托底网格计算调度(公共)-3-2-02查评价模板简称-评价模板ID不能为空", false);
                    Assert.isNull(queryEvaTempDetailReq.getSubjectLifeCycle(), "D3-新增托底网格计算调度(公共)-3-2-02查评价模板简称-主体生命周期不能为空", false);
                    omsEvaluationTemplate = mOmsEvaluationTemplateService.queryEvaTempDetail(queryEvaTempDetailReq)/*vcase invoke 本地 method 方法调用;*/;


                    OmsExecuteCycleStage omsExecuteCycleStage = null;
                    QueryExecuteCycleStageDetailReq queryExecuteCycleStageDetailReq = new QueryExecuteCycleStageDetailReq();
                    queryExecuteCycleStageDetailReq.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:1049626_1_46382
                    if (reqDto != null) {
                        queryExecuteCycleStageDetailReq.setExecuteCycleStageId(reqDto.getExecuteCycleStageId());//SimpleFieldAssign//sourceId:1049624_1_46382
                    }

                    /*3-3-07查执行周期阶段名称（用于增调度使用）[2429]   */
                    Assert.isNull(queryExecuteCycleStageDetailReq.getExecuteCycleStageId(), "D3-新增托底网格计算调度(公共)-3-3-07查执行周期阶段名称（用于增调度使用）-执行周期阶段ID不能为空", false);
                    Assert.isNull(queryExecuteCycleStageDetailReq.getSpaceId(), "D3-新增托底网格计算调度(公共)-3-3-07查执行周期阶段名称（用于增调度使用）-创建于空间ID不能为空", false);
                    omsExecuteCycleStage = mOmsExecuteCycleStageService.queryExecuteCycleStageDetail(queryExecuteCycleStageDetailReq)/*vcase invoke 本地 method 方法调用;*/;


                    AddTimerTaskPlanComRespDto addTimerTaskPlanComRespDto = null;
                    if (omsExecuteCycleStage != null && omsEvaluationTemplate != null && obtainStatisticsUpdateExecuteProgressComRespDto != null) {
                        AddTimerTaskPlanComReqDto addTimerTaskPlanComReqDto = new AddTimerTaskPlanComReqDto();
                        addTimerTaskPlanComReqDto.setIsCompensateTask("FALSE");//sourceId:1041776_1_46383
                        addTimerTaskPlanComReqDto.setDispatchActionTypeCode("DISPATCH_EXECUTE_GRID_CALC_TASK");//sourceId:1041777_1_46383
                        addTimerTaskPlanComReqDto.setTaskDispatchTypeCode("CONTENT_SUBTASK");//sourceId:1041778_1_46383
                        addTimerTaskPlanComReqDto.setObjectTypeCode("OMS_EVALUATION_TEMPLATE");//sourceId:1041779_1_46383
                        addTimerTaskPlanComReqDto.setAddRuleInfoTypeCode("OMS_CYCLE");//sourceId:1041782_1_46383
                        addTimerTaskPlanComReqDto.setThemeContentTypeCode("OMS_EVALUATION_TEMPLATE");//sourceId:1041796_1_46383
                        addTimerTaskPlanComReqDto.setIsAppointSimpleMq("FALSE");//sourceId:1041793_1_46383
                        addTimerTaskPlanComReqDto.setIsComplete("FALSE");//sourceId:1041791_1_46383
                        addTimerTaskPlanComReqDto.setIsRealTimeaSync("TRUE");//sourceId:1041802_1_46383
                        addTimerTaskPlanComReqDto.setOperationInductionId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecInductionRecordId());//CURRENT_INDUCTIONID//sourceId:1041788_1_46383
                        addTimerTaskPlanComReqDto.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:1041789_1_46383
                        addTimerTaskPlanComReqDto.setAppId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecAppId());//CURRENT_APPID//sourceId:1041790_1_46383
                        if (omsExecuteCycleStage != null) {
                            addTimerTaskPlanComReqDto.setCycleStandardName(omsExecuteCycleStage.getCycleStandardName());//SimpleFieldAssign//sourceId:1041957_1_46383
                        }
                        if (omsEvaluationTemplate != null) {
                            addTimerTaskPlanComReqDto.setTargetContentName(omsEvaluationTemplate.getEvaluationTempShortName());//SimpleFieldAssign//sourceId:1041956_1_46383
                        }
                        if (reqDto != null) {
                            addTimerTaskPlanComReqDto.setObjectId(reqDto.getThemeContentId());//SimpleFieldAssign//sourceId:1041780_1_46383
                            addTimerTaskPlanComReqDto.setAddRuleInfoId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:1041783_1_46383
                            addTimerTaskPlanComReqDto.setThemeContentId(reqDto.getThemeContentId());//SimpleFieldAssign//sourceId:1041797_1_46383
                            addTimerTaskPlanComReqDto.setStandbyField1(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1041781_1_46383
                            addTimerTaskPlanComReqDto.setStandbyField3(reqDto.getExecuteCycleStageId());//SimpleFieldAssign//sourceId:1049628_1_46383
                            addTimerTaskPlanComReqDto.setStandbyField4(reqDto.getTargetId());//SimpleFieldAssign//sourceId:1059220_1_46383
                        }
                        if (obtainStatisticsUpdateExecuteProgressComRespDto != null) {
                            addTimerTaskPlanComReqDto.setStandbyField2(obtainStatisticsUpdateExecuteProgressComRespDto.getExecuteProgressId());//SimpleFieldAssign//sourceId:1041798_1_46383
                        }

                        /*D3新增定时任务调度(公共)[4995]   */
                        Assert.isNull(addTimerTaskPlanComReqDto.getCycleStandardName(), "D3-新增托底网格计算调度(公共)-D3新增定时任务调度(公共)-周期名称不能为空", false);
                        Assert.isNull(addTimerTaskPlanComReqDto.getTargetContentName(), "D3-新增托底网格计算调度(公共)-D3新增定时任务调度(公共)-目标内容名称不能为空", false);
                        Assert.isNull(addTimerTaskPlanComReqDto.getIsCompensateTask(), "D3-新增托底网格计算调度(公共)-D3新增定时任务调度(公共)-是否补偿任务不能为空", false);
                        Assert.isNull(addTimerTaskPlanComReqDto.getDispatchActionTypeCode(), "D3-新增托底网格计算调度(公共)-D3新增定时任务调度(公共)-任务调度的行为类型编码不能为空", false);
                        Assert.isNull(addTimerTaskPlanComReqDto.getTaskDispatchTypeCode(), "D3-新增托底网格计算调度(公共)-D3新增定时任务调度(公共)-任务调度类型编码不能为空", false);
                        Assert.isNull(addTimerTaskPlanComReqDto.getObjectTypeCode(), "D3-新增托底网格计算调度(公共)-D3新增定时任务调度(公共)-归属对象类型编码不能为空", false);
                        Assert.isNull(addTimerTaskPlanComReqDto.getObjectId(), "D3-新增托底网格计算调度(公共)-D3新增定时任务调度(公共)-归属对象内容ID不能为空", false);
                        Assert.isNull(addTimerTaskPlanComReqDto.getAddRuleInfoTypeCode(), "D3-新增托底网格计算调度(公共)-D3新增定时任务调度(公共)-生成规则信息类型编码不能为空", false);
                        Assert.isNull(addTimerTaskPlanComReqDto.getAddRuleInfoId(), "D3-新增托底网格计算调度(公共)-D3新增定时任务调度(公共)-生成辅助规则信息值不能为空", false);
                        Assert.isNull(addTimerTaskPlanComReqDto.getThemeContentTypeCode(), "D3-新增托底网格计算调度(公共)-D3新增定时任务调度(公共)-主题内容类型编码不能为空", false);
                        Assert.isNull(addTimerTaskPlanComReqDto.getThemeContentId(), "D3-新增托底网格计算调度(公共)-D3新增定时任务调度(公共)-主题内容ID不能为空", false);
                        Assert.isNull(addTimerTaskPlanComReqDto.getStandbyField1(), "D3-新增托底网格计算调度(公共)-D3新增定时任务调度(公共)-备用字段1不能为空", false);
                        Assert.isNull(addTimerTaskPlanComReqDto.getStandbyField2(), "D3-新增托底网格计算调度(公共)-D3新增定时任务调度(公共)-备用字段2不能为空", false);
                        Assert.isNull(addTimerTaskPlanComReqDto.getStandbyField3(), "D3-新增托底网格计算调度(公共)-D3新增定时任务调度(公共)-备用字段3不能为空", false);
                        Assert.isNull(addTimerTaskPlanComReqDto.getIsAppointSimpleMq(), "D3-新增托底网格计算调度(公共)-D3新增定时任务调度(公共)-是否固化消息队列不能为空", false);
                        Assert.isNull(addTimerTaskPlanComReqDto.getIsComplete(), "D3-新增托底网格计算调度(公共)-D3新增定时任务调度(公共)-是否执行完成不能为空", false);
                        Assert.isNull(addTimerTaskPlanComReqDto.getIsRealTimeaSync(), "D3-新增托底网格计算调度(公共)-D3新增定时任务调度(公共)-是否实时异步调度不能为空", false);
                        Assert.isNull(addTimerTaskPlanComReqDto.getOperationInductionId(), "D3-新增托底网格计算调度(公共)-D3新增定时任务调度(公共)-操作人就职记录ID不能为空", false);
                        Assert.isNull(addTimerTaskPlanComReqDto.getSpaceId(), "D3-新增托底网格计算调度(公共)-D3新增定时任务调度(公共)-创建于空间ID不能为空", false);
                        Assert.isNull(addTimerTaskPlanComReqDto.getAppId(), "D3-新增托底网格计算调度(公共)-D3新增定时任务调度(公共)-创建于联盟应用ID不能为空", false);
                        addTimerTaskPlanComRespDto = taskGenService.addTimerTaskPlanCom(addTimerTaskPlanComReqDto)/*vcase invoke isSameApp*/;


                    }
//ModelCode: receptionService
                    ImplementAcceptFieldRespDto receptionServiceRes = null;
                    if (addTimerTaskPlanComRespDto != null) {
                        ImplementAcceptFieldReqDto receptionServiceReq = new ImplementAcceptFieldReqDto();
                        if (addTimerTaskPlanComRespDto != null) {
                            receptionServiceReq.setTimingTaskDispatchId(addTimerTaskPlanComRespDto.getTimingTaskDispatchId());//SimpleFieldAssign//sourceId:1042720_1_46384
                        }

                        /*出参字段：定时任务调度ID[6100]  用于特殊方法接收上游入参。 */
                        Assert.isNull(receptionServiceReq.getTimingTaskDispatchId(), "D3-新增托底网格计算调度(公共)-出参字段：定时任务调度ID-定时任务调度记录ID不能为空", false);
                        receptionServiceRes = nbGridCalculate.implementAcceptField(receptionServiceReq);


                        receptionServiceRes_1 = receptionServiceRes;
                    }
                    ImplementDistributedUnlockingComRespDto implementDistributedUnlockingComRespDto = null;
                    if (obtainLockSemanticInstanceComRespDto != null) {
                        ImplementDistributedUnlockingComReqDto implementDistributedUnlockingComReqDto = new ImplementDistributedUnlockingComReqDto();
                        if (obtainLockSemanticInstanceComRespDto != null) {
                            implementDistributedUnlockingComReqDto.setCommPrimaryKey(obtainLockSemanticInstanceComRespDto.getObjectName());//SimpleFieldAssign//sourceId:1065134_1_46385
                        }

                        /*D3分布式解锁(公共)[7250]   */
                        Assert.isNull(implementDistributedUnlockingComReqDto.getCommPrimaryKey(), "D3-新增托底网格计算调度(公共)-D3分布式解锁(公共)-通用主键ID不能为空", false);
                        implementDistributedUnlockingComRespDto = interfaceModeService.implementDistributedUnlockingCom(implementDistributedUnlockingComReqDto)/*vcase invoke isSameApp*/;

                        bLock = false;

                    }
                } else if ((implementDistributedLockingComRespDto != null && implementDistributedLockingComRespDto.getTureOrFalse() != null && implementDistributedLockingComRespDto.getTureOrFalse().equals("FALSE"))) {
                    //elseif(D3分布式加锁(公共).加锁是否成功 等于 否)  46377

//processBranchName:正常结束 ,processBranchId:46379

                }
            } else if ((listOmsTargetTimingTaskDispatch != null && listOmsTargetTimingTaskDispatch != null && listOmsTargetTimingTaskDispatch.size() == 1)) {
                //elseif(3-2-09查未完成的全网格计算标准数据调度列表.定时任务调度列表数据集条数 等于 1)  45937

                ObtainLockSemanticInstanceComRespDto obtainLockSemanticInstanceComRespDto_2 = null;
                ObtainLockSemanticInstanceComReqDto obtainLockSemanticInstanceComReqDto_1 = new ObtainLockSemanticInstanceComReqDto();
                obtainLockSemanticInstanceComReqDto_1.setTemplateSemanticEngineCode("ADD_TEMP_ALL_CONTENT_CALC_LOCK_KEY");//CUSTOM_CONVENTION//sourceId:1065135_1_46413
                if (reqDto != null) {
                    obtainLockSemanticInstanceComReqDto_1.setEvaluationTemplateId(reqDto.getThemeContentId());//SimpleFieldAssign//sourceId:1065137_1_46413
                }

                /*D2获取分布式锁语义实例(公共)[7255]   */
                Assert.isNull(obtainLockSemanticInstanceComReqDto_1.getTemplateSemanticEngineCode(), "D3-新增托底网格计算调度(公共)-D2获取分布式锁语义实例(公共)-模板引擎标识不能为空", false);
                Assert.isNull(obtainLockSemanticInstanceComReqDto_1.getEvaluationTemplateId(), "D3-新增托底网格计算调度(公共)-D2获取分布式锁语义实例(公共)-冗余评价模板ID不能为空", false);
                obtainLockSemanticInstanceComRespDto_2 = fwCompTemplateEngineClient.obtainLockSemanticInstanceCom(obtainLockSemanticInstanceComReqDto_1).getData()/*vcase invoke 跨dubbo调用;*/;

                key = obtainLockSemanticInstanceComRespDto_2.getObjectName();

                ImplementDistributedLockingComRespDto implementDistributedLockingComRespDto_2 = null;
                if (obtainLockSemanticInstanceComRespDto_2 != null) {
                    ImplementDistributedLockingComReqDto implementDistributedLockingComReqDto_1 = new ImplementDistributedLockingComReqDto();
                    implementDistributedLockingComReqDto_1.setDuration(Long.valueOf(120));//CUSTOM_CONVENTION//sourceId:1065132_1_46414
                    if (obtainLockSemanticInstanceComRespDto_2 != null) {
                        implementDistributedLockingComReqDto_1.setCommPrimaryKey(obtainLockSemanticInstanceComRespDto_2.getObjectName());//SimpleFieldAssign//sourceId:1065133_1_46414
                    }

                    /*D3分布式加锁(公共)[7253]   */
                    Assert.isNull(implementDistributedLockingComReqDto_1.getCommPrimaryKey(), "D3-新增托底网格计算调度(公共)-D3分布式加锁(公共)-通用主键ID不能为空", false);
                    Assert.isNull(implementDistributedLockingComReqDto_1.getDuration(), "D3-新增托底网格计算调度(公共)-D3分布式加锁(公共)-锁定时长不能为空", false);
                    implementDistributedLockingComRespDto_2 = interfaceModeService.implementDistributedLockingCom(implementDistributedLockingComReqDto_1)/*vcase invoke isSameApp*/;


                }
                if ((implementDistributedLockingComRespDto_2 != null && implementDistributedLockingComRespDto_2.getTureOrFalse() != null && implementDistributedLockingComRespDto_2.getTureOrFalse().equals("TRUE"))) {
                    //if(D3分布式加锁(公共).加锁是否成功 等于 是)  46415

                    bLock = true;
                    OmsEvaluationTemplate omsEvaluationTemplate_2 = null;
                    QueryEvaTempDetailReq queryEvaTempDetailReq_1 = new QueryEvaTempDetailReq();
                    queryEvaTempDetailReq_1.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1041895_1_46418
                    if (reqDto != null) {
                        queryEvaTempDetailReq_1.setTargetId(reqDto.getTargetId());//SimpleFieldAssign//sourceId:1041922_1_46418
                        queryEvaTempDetailReq_1.setEvaluationTemplateId(reqDto.getThemeContentId());//SimpleFieldAssign//sourceId:1041894_1_46418
                    }

                    /*3-2-02查评价模板简称[2316]   */
                    Assert.isNull(queryEvaTempDetailReq_1.getTargetId(), "D3-新增托底网格计算调度(公共)-3-2-02查评价模板简称-对应的目标ID不能为空", false);
                    Assert.isNull(queryEvaTempDetailReq_1.getEvaluationTemplateId(), "D3-新增托底网格计算调度(公共)-3-2-02查评价模板简称-评价模板ID不能为空", false);
                    Assert.isNull(queryEvaTempDetailReq_1.getSubjectLifeCycle(), "D3-新增托底网格计算调度(公共)-3-2-02查评价模板简称-主体生命周期不能为空", false);
                    omsEvaluationTemplate_2 = mOmsEvaluationTemplateService.queryEvaTempDetail(queryEvaTempDetailReq_1)/*vcase invoke 本地 method 方法调用;*/;


                    OmsExecuteCycleStage omsExecuteCycleStage_2 = null;
                    QueryExecuteCycleStageDetailReq queryExecuteCycleStageDetailReq_1 = new QueryExecuteCycleStageDetailReq();
                    queryExecuteCycleStageDetailReq_1.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:1049626_1_46419
                    if (reqDto != null) {
                        queryExecuteCycleStageDetailReq_1.setExecuteCycleStageId(reqDto.getExecuteCycleStageId());//SimpleFieldAssign//sourceId:1049624_1_46419
                    }

                    /*3-3-07查执行周期阶段名称（用于增调度使用）[2429]   */
                    Assert.isNull(queryExecuteCycleStageDetailReq_1.getExecuteCycleStageId(), "D3-新增托底网格计算调度(公共)-3-3-07查执行周期阶段名称（用于增调度使用）-执行周期阶段ID不能为空", false);
                    Assert.isNull(queryExecuteCycleStageDetailReq_1.getSpaceId(), "D3-新增托底网格计算调度(公共)-3-3-07查执行周期阶段名称（用于增调度使用）-创建于空间ID不能为空", false);
                    omsExecuteCycleStage_2 = mOmsExecuteCycleStageService.queryExecuteCycleStageDetail(queryExecuteCycleStageDetailReq_1)/*vcase invoke 本地 method 方法调用;*/;


                    AddTimerTaskPlanComRespDto addTimerTaskPlanComRespDto_2 = null;
                    if (omsExecuteCycleStage_2 != null && omsEvaluationTemplate_2 != null && obtainStatisticsUpdateExecuteProgressComRespDto != null) {
                        AddTimerTaskPlanComReqDto addTimerTaskPlanComReqDto_1 = new AddTimerTaskPlanComReqDto();
                        addTimerTaskPlanComReqDto_1.setIsCompensateTask("FALSE");//sourceId:1041776_1_46420
                        addTimerTaskPlanComReqDto_1.setDispatchActionTypeCode("DISPATCH_EXECUTE_GRID_CALC_TASK");//sourceId:1041777_1_46420
                        addTimerTaskPlanComReqDto_1.setTaskDispatchTypeCode("CONTENT_SUBTASK");//sourceId:1041778_1_46420
                        addTimerTaskPlanComReqDto_1.setObjectTypeCode("OMS_EVALUATION_TEMPLATE");//sourceId:1041779_1_46420
                        addTimerTaskPlanComReqDto_1.setAddRuleInfoTypeCode("OMS_CYCLE");//sourceId:1041782_1_46420
                        addTimerTaskPlanComReqDto_1.setThemeContentTypeCode("OMS_EVALUATION_TEMPLATE");//sourceId:1041796_1_46420
                        addTimerTaskPlanComReqDto_1.setIsAppointSimpleMq("FALSE");//sourceId:1041793_1_46420
                        addTimerTaskPlanComReqDto_1.setIsComplete("FALSE");//sourceId:1041791_1_46420
                        addTimerTaskPlanComReqDto_1.setIsRealTimeaSync("TRUE");//sourceId:1041802_1_46420
                        addTimerTaskPlanComReqDto_1.setOperationInductionId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecInductionRecordId());//CURRENT_INDUCTIONID//sourceId:1041788_1_46420
                        addTimerTaskPlanComReqDto_1.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:1041789_1_46420
                        addTimerTaskPlanComReqDto_1.setAppId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecAppId());//CURRENT_APPID//sourceId:1041790_1_46420
                        if (omsExecuteCycleStage_2 != null) {
                            addTimerTaskPlanComReqDto_1.setCycleStandardName(omsExecuteCycleStage_2.getCycleStandardName());//SimpleFieldAssign//sourceId:1041957_1_46420
                        }
                        if (omsEvaluationTemplate_2 != null) {
                            addTimerTaskPlanComReqDto_1.setTargetContentName(omsEvaluationTemplate_2.getEvaluationTempShortName());//SimpleFieldAssign//sourceId:1041956_1_46420
                        }
                        if (reqDto != null) {
                            addTimerTaskPlanComReqDto_1.setObjectId(reqDto.getThemeContentId());//SimpleFieldAssign//sourceId:1041780_1_46420
                            addTimerTaskPlanComReqDto_1.setAddRuleInfoId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:1041783_1_46420
                            addTimerTaskPlanComReqDto_1.setThemeContentId(reqDto.getThemeContentId());//SimpleFieldAssign//sourceId:1041797_1_46420
                            addTimerTaskPlanComReqDto_1.setStandbyField1(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1041781_1_46420
                            addTimerTaskPlanComReqDto_1.setStandbyField3(reqDto.getExecuteCycleStageId());//SimpleFieldAssign//sourceId:1049628_1_46420
                            addTimerTaskPlanComReqDto_1.setStandbyField4(reqDto.getTargetId());//SimpleFieldAssign//sourceId:1059220_1_46420
                        }
                        if (obtainStatisticsUpdateExecuteProgressComRespDto != null) {
                            addTimerTaskPlanComReqDto_1.setStandbyField2(obtainStatisticsUpdateExecuteProgressComRespDto.getExecuteProgressId());//SimpleFieldAssign//sourceId:1041798_1_46420
                        }

                        /*D3新增定时任务调度(公共)[4995]   */
                        Assert.isNull(addTimerTaskPlanComReqDto_1.getCycleStandardName(), "D3-新增托底网格计算调度(公共)-D3新增定时任务调度(公共)-周期名称不能为空", false);
                        Assert.isNull(addTimerTaskPlanComReqDto_1.getTargetContentName(), "D3-新增托底网格计算调度(公共)-D3新增定时任务调度(公共)-目标内容名称不能为空", false);
                        Assert.isNull(addTimerTaskPlanComReqDto_1.getIsCompensateTask(), "D3-新增托底网格计算调度(公共)-D3新增定时任务调度(公共)-是否补偿任务不能为空", false);
                        Assert.isNull(addTimerTaskPlanComReqDto_1.getDispatchActionTypeCode(), "D3-新增托底网格计算调度(公共)-D3新增定时任务调度(公共)-任务调度的行为类型编码不能为空", false);
                        Assert.isNull(addTimerTaskPlanComReqDto_1.getTaskDispatchTypeCode(), "D3-新增托底网格计算调度(公共)-D3新增定时任务调度(公共)-任务调度类型编码不能为空", false);
                        Assert.isNull(addTimerTaskPlanComReqDto_1.getObjectTypeCode(), "D3-新增托底网格计算调度(公共)-D3新增定时任务调度(公共)-归属对象类型编码不能为空", false);
                        Assert.isNull(addTimerTaskPlanComReqDto_1.getObjectId(), "D3-新增托底网格计算调度(公共)-D3新增定时任务调度(公共)-归属对象内容ID不能为空", false);
                        Assert.isNull(addTimerTaskPlanComReqDto_1.getAddRuleInfoTypeCode(), "D3-新增托底网格计算调度(公共)-D3新增定时任务调度(公共)-生成规则信息类型编码不能为空", false);
                        Assert.isNull(addTimerTaskPlanComReqDto_1.getAddRuleInfoId(), "D3-新增托底网格计算调度(公共)-D3新增定时任务调度(公共)-生成辅助规则信息值不能为空", false);
                        Assert.isNull(addTimerTaskPlanComReqDto_1.getThemeContentTypeCode(), "D3-新增托底网格计算调度(公共)-D3新增定时任务调度(公共)-主题内容类型编码不能为空", false);
                        Assert.isNull(addTimerTaskPlanComReqDto_1.getThemeContentId(), "D3-新增托底网格计算调度(公共)-D3新增定时任务调度(公共)-主题内容ID不能为空", false);
                        Assert.isNull(addTimerTaskPlanComReqDto_1.getStandbyField1(), "D3-新增托底网格计算调度(公共)-D3新增定时任务调度(公共)-备用字段1不能为空", false);
                        Assert.isNull(addTimerTaskPlanComReqDto_1.getStandbyField2(), "D3-新增托底网格计算调度(公共)-D3新增定时任务调度(公共)-备用字段2不能为空", false);
                        Assert.isNull(addTimerTaskPlanComReqDto_1.getStandbyField3(), "D3-新增托底网格计算调度(公共)-D3新增定时任务调度(公共)-备用字段3不能为空", false);
                        Assert.isNull(addTimerTaskPlanComReqDto_1.getIsAppointSimpleMq(), "D3-新增托底网格计算调度(公共)-D3新增定时任务调度(公共)-是否固化消息队列不能为空", false);
                        Assert.isNull(addTimerTaskPlanComReqDto_1.getIsComplete(), "D3-新增托底网格计算调度(公共)-D3新增定时任务调度(公共)-是否执行完成不能为空", false);
                        Assert.isNull(addTimerTaskPlanComReqDto_1.getIsRealTimeaSync(), "D3-新增托底网格计算调度(公共)-D3新增定时任务调度(公共)-是否实时异步调度不能为空", false);
                        Assert.isNull(addTimerTaskPlanComReqDto_1.getOperationInductionId(), "D3-新增托底网格计算调度(公共)-D3新增定时任务调度(公共)-操作人就职记录ID不能为空", false);
                        Assert.isNull(addTimerTaskPlanComReqDto_1.getSpaceId(), "D3-新增托底网格计算调度(公共)-D3新增定时任务调度(公共)-创建于空间ID不能为空", false);
                        Assert.isNull(addTimerTaskPlanComReqDto_1.getAppId(), "D3-新增托底网格计算调度(公共)-D3新增定时任务调度(公共)-创建于联盟应用ID不能为空", false);
                        addTimerTaskPlanComRespDto_2 = taskGenService.addTimerTaskPlanCom(addTimerTaskPlanComReqDto_1)/*vcase invoke isSameApp*/;


                    }
//ModelCode: receptionService
                    ImplementAcceptFieldRespDto receptionServiceRes_2 = null;
                    if (addTimerTaskPlanComRespDto_2 != null) {
                        ImplementAcceptFieldReqDto receptionServiceReq_1 = new ImplementAcceptFieldReqDto();
                        if (addTimerTaskPlanComRespDto_2 != null) {
                            receptionServiceReq_1.setTimingTaskDispatchId(addTimerTaskPlanComRespDto_2.getTimingTaskDispatchId());//SimpleFieldAssign//sourceId:1042720_1_46421
                        }

                        /*出参字段：定时任务调度ID[6100]  用于特殊方法接收上游入参。 */
                        Assert.isNull(receptionServiceReq_1.getTimingTaskDispatchId(), "D3-新增托底网格计算调度(公共)-出参字段：定时任务调度ID-定时任务调度记录ID不能为空", false);
                        receptionServiceRes_2 = nbGridCalculate.implementAcceptField(receptionServiceReq_1);


                        receptionServiceRes_1 = receptionServiceRes_2;
                    }
                    ImplementDistributedUnlockingComRespDto implementDistributedUnlockingComRespDto_1 = null;
                    if (obtainLockSemanticInstanceComRespDto_2 != null) {
                        ImplementDistributedUnlockingComReqDto implementDistributedUnlockingComReqDto_1 = new ImplementDistributedUnlockingComReqDto();
                        if (obtainLockSemanticInstanceComRespDto_2 != null) {
                            implementDistributedUnlockingComReqDto_1.setCommPrimaryKey(obtainLockSemanticInstanceComRespDto_2.getObjectName());//SimpleFieldAssign//sourceId:1065134_1_46422
                        }

                        /*D3分布式解锁(公共)[7250]   */
                        Assert.isNull(implementDistributedUnlockingComReqDto_1.getCommPrimaryKey(), "D3-新增托底网格计算调度(公共)-D3分布式解锁(公共)-通用主键ID不能为空", false);
                        implementDistributedUnlockingComRespDto_1 = interfaceModeService.implementDistributedUnlockingCom(implementDistributedUnlockingComReqDto_1)/*vcase invoke isSameApp*/;
                        bLock = false;


                    }
                } else if ((implementDistributedLockingComRespDto_2 != null && implementDistributedLockingComRespDto_2.getTureOrFalse() != null && implementDistributedLockingComRespDto_2.getTureOrFalse().equals("FALSE"))) {
                    //elseif(D3分布式加锁(公共).加锁是否成功 等于 否)  46416

//processBranchName:正常结束 ,processBranchId:46417

                }
            } else if ((listOmsTargetTimingTaskDispatch != null && listOmsTargetTimingTaskDispatch != null && listOmsTargetTimingTaskDispatch.size() >= 2)) {
                //elseif(3-2-09查未完成的全网格计算标准数据调度列表.定时任务调度列表数据集条数 大于等于 2)  45957

                CalculateOldestOfMultipleNumComRespDto calculateOldestOfMultipleNumComRespDto = null;
                if (listOmsTargetTimingTaskDispatch != null && !CollectionUtil.isEmpty(listOmsTargetTimingTaskDispatch) && listOmsTargetTimingTaskDispatch.size() > 0) {
                    CalculateOldestOfMultipleNumComReqDto calculateOldestOfMultipleNumComReqDto = new CalculateOldestOfMultipleNumComReqDto();
                    if (listOmsTargetTimingTaskDispatch != null && !CollectionUtil.isEmpty(listOmsTargetTimingTaskDispatch) && listOmsTargetTimingTaskDispatch != null && !CollectionUtil.isEmpty(listOmsTargetTimingTaskDispatch)) {
                        calculateOldestOfMultipleNumComReqDto.setOldestOfMultipleNumList(//objList-to-objLists
                                listOmsTargetTimingTaskDispatch.stream().map(item -> {
                                    OldestOfMultipleNumDto elm = new OldestOfMultipleNumDto();
                                    elm.setCommPrimaryKey(item.getTimingTaskDispatchId());//SimpleFieldAssign//sourceId:222498_2_45967
                                    elm.setComTimeField(item.getCreateTime());//SimpleFieldAssign//sourceId:222499_2_45967
                                    return elm;
                                }).collect(Collectors.toList()));//objList-to-objLists//sourceId:1053157_1_45967
                    }

                    /*D4-计算数据集取最早(公共)[7233]   */

                    calculateOldestOfMultipleNumComRespDto = fwCalcCalculationRulesClient.calculateOldestOfMultipleNumCom(calculateOldestOfMultipleNumComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


                }
//ModelCode: receptionService
                ImplementAcceptFieldRespDto receptionServiceRes_3 = null;
                if (calculateOldestOfMultipleNumComRespDto != null) {
                    ImplementAcceptFieldReqDto receptionServiceReq_2 = new ImplementAcceptFieldReqDto();
                    if (calculateOldestOfMultipleNumComRespDto != null) {
                        receptionServiceReq_2.setTimingTaskDispatchId(calculateOldestOfMultipleNumComRespDto.getCommPrimaryKey());//SimpleFieldAssign//sourceId:1042720_1_45968
                    }

                    /*出参字段：定时任务调度ID[6100]  用于特殊方法接收上游入参。 */
                    Assert.isNull(receptionServiceReq_2.getTimingTaskDispatchId(), "D3-新增托底网格计算调度(公共)-出参字段：定时任务调度ID-定时任务调度记录ID不能为空", false);
                    receptionServiceRes_3 = nbGridCalculate.implementAcceptField(receptionServiceReq_2);


                    receptionServiceRes_1 = receptionServiceRes_3;
                }
            }
        } finally {
            if (bLock) {
                ImplementDistributedUnlockingComReqDto implementDistributedUnlockingComReqDto = new ImplementDistributedUnlockingComReqDto();
                implementDistributedUnlockingComReqDto.setCommPrimaryKey(key);
                interfaceModeService.implementDistributedUnlockingCom(implementDistributedUnlockingComReqDto)/*vcase invoke isSameApp*/;
            }
        }


        AddUnderCalcGridDispatchComRespDto retData = new AddUnderCalcGridDispatchComRespDto();
        if (receptionServiceRes_1 != null) {
            retData.setTimingTaskDispatchId(receptionServiceRes_1.getTimingTaskDispatchId());//SimpleFieldAssign//sourceId:1042721_1
        }


        return retData;
    }

    /**
     * D3-执行获取目标内容子周期(公共)[7120]
     * gen by moon at 10/13/2023, 12:02:18 AM
     */
    @Trace(operationName = "D3-执行获取目标内容子周期(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementFindSubTargetCycleComRespDto implementFindSubTargetCycleCom(ImplementFindSubTargetCycleComReqDto reqDto) {


        CalculateAcceptAboveFieldsRespDto receptionServiceRes_1 = null;
        if ((reqDto != null && reqDto.getStandardDataCalcCycleModel() != null && reqDto.getStandardDataCalcCycleModel().equals("MID_CYCLE") || reqDto != null && reqDto.getStandardDataCalcCycleModel() != null && reqDto.getStandardDataCalcCycleModel().equals("PARENT_CYCLE"))) {
            //if((D3-执行获取目标内容子周期(公共).标准数据计算周期模型 等于 中期 or D3-执行获取目标内容子周期(公共).标准数据计算周期模型 等于 父周期))  44056

            OmsEvaluationObjectTargetCycle omsEvaluationObjectTargetCycle = null;
            QueryEvaObjTargetCycleDetailReq queryEvaObjTargetCycleDetailReq = new QueryEvaObjTargetCycleDetailReq();
            queryEvaObjTargetCycleDetailReq.setIsArchive("FALSE");//sourceId:1049841_1_44058
            if (reqDto != null) {
                queryEvaObjTargetCycleDetailReq.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1005760_1_44058
                queryEvaObjTargetCycleDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1005761_1_44058
            }

            /*3-3-09查目标周期详情（获取树&内容信息）[2313]   */
            Assert.isNull(queryEvaObjTargetCycleDetailReq.getEvaObjTargetCycleId(), "D3-执行获取目标内容子周期(公共)-3-3-09查目标周期详情（获取树&内容信息）-被评对象目标周期ID不能为空", false);
            Assert.isNull(queryEvaObjTargetCycleDetailReq.getEvaluationTemplateId(), "D3-执行获取目标内容子周期(公共)-3-3-09查目标周期详情（获取树&内容信息）-冗余评价模板ID不能为空", false);
            Assert.isNull(queryEvaObjTargetCycleDetailReq.getIsArchive(), "D3-执行获取目标内容子周期(公共)-3-3-09查目标周期详情（获取树&内容信息）-是否存档不能为空", false);
            omsEvaluationObjectTargetCycle = mOmsEvaluationObjectTargetCycleService.queryEvaObjTargetCycleDetail(queryEvaObjTargetCycleDetailReq)/*vcase invoke 本地 method 方法调用;*/;


            ObtainCurrentTargetContexeCuteCycleComRespDto obtainCurrentTargetContexeCuteCycleComRespDto = null;
            if (omsEvaluationObjectTargetCycle != null) {
                ObtainCurrentTargetContexeCuteCycleComReqDto obtainCurrentTargetContexeCuteCycleComReqDto = new ObtainCurrentTargetContexeCuteCycleComReqDto();
                if (reqDto != null) {
                    obtainCurrentTargetContexeCuteCycleComReqDto.setCycleId(reqDto.getUpdateCycleId());//SimpleFieldAssign//sourceId:1170161_1_49903
                    obtainCurrentTargetContexeCuteCycleComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1170164_1_49903
                }
                if (omsEvaluationObjectTargetCycle != null) {
                    obtainCurrentTargetContexeCuteCycleComReqDto.setTargetCycleContentId(omsEvaluationObjectTargetCycle.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1170162_1_49903
                    obtainCurrentTargetContexeCuteCycleComReqDto.setTargetId(omsEvaluationObjectTargetCycle.getTargetId());//SimpleFieldAssign//sourceId:1170163_1_49903
                }

                /*D3获取当前目标内容执行周期(公共)[7501]   */
                Assert.isNull(obtainCurrentTargetContexeCuteCycleComReqDto.getCycleId(), "D3-执行获取目标内容子周期(公共)-D3获取当前目标内容执行周期(公共)-周期ID不能为空", false);
                Assert.isNull(obtainCurrentTargetContexeCuteCycleComReqDto.getTargetCycleContentId(), "D3-执行获取目标内容子周期(公共)-D3获取当前目标内容执行周期(公共)-关联目标内容ID不能为空", false);
                Assert.isNull(obtainCurrentTargetContexeCuteCycleComReqDto.getTargetId(), "D3-执行获取目标内容子周期(公共)-D3获取当前目标内容执行周期(公共)-冗余目标ID不能为空", false);
                Assert.isNull(obtainCurrentTargetContexeCuteCycleComReqDto.getEvaluationTemplateId(), "D3-执行获取目标内容子周期(公共)-D3获取当前目标内容执行周期(公共)-冗余评价模板ID不能为空", false);
                obtainCurrentTargetContexeCuteCycleComRespDto = executeCycleService.obtainCurrentTargetContexeCuteCycleCom(obtainCurrentTargetContexeCuteCycleComReqDto)/*vcase invoke isSameApp*/;


            }
            OmsEvaluationObjectTargetCycle omsEvaluationObjectTargetCycle_2 = null;
            if (omsEvaluationObjectTargetCycle != null && obtainCurrentTargetContexeCuteCycleComRespDto != null) {
                QueryTargetCycleByStartAndEndTimeDetailReq queryTargetCycleByStartAndEndTimeDetailReq = new QueryTargetCycleByStartAndEndTimeDetailReq();
                queryTargetCycleByStartAndEndTimeDetailReq.setIsSubCycle("TRUE");//sourceId:1051529_1_44062
                queryTargetCycleByStartAndEndTimeDetailReq.setIsArchive("FALSE");//sourceId:1006045_1_44062
                if (omsEvaluationObjectTargetCycle != null) {
                    queryTargetCycleByStartAndEndTimeDetailReq.setEvaObjEntityId(omsEvaluationObjectTargetCycle.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1006037_1_44062
                    queryTargetCycleByStartAndEndTimeDetailReq.setEvaObjTypeCode(omsEvaluationObjectTargetCycle.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1006038_1_44062
                    queryTargetCycleByStartAndEndTimeDetailReq.setTargetCycleContentId(omsEvaluationObjectTargetCycle.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1051528_1_44062
                }
                if (obtainCurrentTargetContexeCuteCycleComRespDto != null) {
                    queryTargetCycleByStartAndEndTimeDetailReq.setCycleStartTime(obtainCurrentTargetContexeCuteCycleComRespDto.getCycleStartTime());//SimpleFieldAssign//sourceId:1006041_1_44062
                    queryTargetCycleByStartAndEndTimeDetailReq.setCycleEndTime(obtainCurrentTargetContexeCuteCycleComRespDto.getCycleEndTime());//SimpleFieldAssign//sourceId:1006042_1_44062
                }
                if (reqDto != null) {
                    queryTargetCycleByStartAndEndTimeDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1006043_1_44062
                }

                /*3-3-09查目标子周期By开始与结束时间[6551]   */
                Assert.isNull(queryTargetCycleByStartAndEndTimeDetailReq.getEvaObjEntityId(), "D3-执行获取目标内容子周期(公共)-3-3-09查目标子周期By开始与结束时间-被评对象内容表主键ID不能为空", false);
                Assert.isNull(queryTargetCycleByStartAndEndTimeDetailReq.getEvaObjTypeCode(), "D3-执行获取目标内容子周期(公共)-3-3-09查目标子周期By开始与结束时间-被评对象类型编码不能为空", false);
                Assert.isNull(queryTargetCycleByStartAndEndTimeDetailReq.getTargetCycleContentId(), "D3-执行获取目标内容子周期(公共)-3-3-09查目标子周期By开始与结束时间-关联目标内容ID不能为空", false);
                Assert.isNull(queryTargetCycleByStartAndEndTimeDetailReq.getCycleStartTime(), "D3-执行获取目标内容子周期(公共)-3-3-09查目标子周期By开始与结束时间-目标计划开始时间不能为空", false);
                Assert.isNull(queryTargetCycleByStartAndEndTimeDetailReq.getCycleEndTime(), "D3-执行获取目标内容子周期(公共)-3-3-09查目标子周期By开始与结束时间-目标计划结束时间不能为空", false);
                Assert.isNull(queryTargetCycleByStartAndEndTimeDetailReq.getIsSubCycle(), "D3-执行获取目标内容子周期(公共)-3-3-09查目标子周期By开始与结束时间-是否子周期不能为空", false);
                Assert.isNull(queryTargetCycleByStartAndEndTimeDetailReq.getEvaluationTemplateId(), "D3-执行获取目标内容子周期(公共)-3-3-09查目标子周期By开始与结束时间-冗余评价模板ID不能为空", false);
                Assert.isNull(queryTargetCycleByStartAndEndTimeDetailReq.getIsArchive(), "D3-执行获取目标内容子周期(公共)-3-3-09查目标子周期By开始与结束时间-是否存档不能为空", false);
                omsEvaluationObjectTargetCycle_2 = mOmsEvaluationObjectTargetCycleService.queryTargetCycleByStartAndEndTimeDetail(queryTargetCycleByStartAndEndTimeDetailReq)/*vcase invoke 本地 method 方法调用;*/;


            }
//ModelCode: receptionService
            CalculateAcceptAboveFieldsRespDto receptionServiceRes = null;
            if (omsEvaluationObjectTargetCycle_2 != null) {
                CalculateAcceptAboveFieldsReqDto receptionServiceReq = new CalculateAcceptAboveFieldsReqDto();
                if (omsEvaluationObjectTargetCycle_2 != null) {
                    receptionServiceReq.setEvaObjTargetCycleId(omsEvaluationObjectTargetCycle_2.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1006016_1_44063
                }

                /*约定出参：更新周期对应的目标周期ID[6495]  用于特殊方法接收上游入参。 */
                Assert.isNull(receptionServiceReq.getEvaObjTargetCycleId(), "D3-执行获取目标内容子周期(公共)-约定出参：更新周期对应的目标周期ID-被评对象目标周期ID不能为空", false);
                receptionServiceRes = nbGridCalculate.calculateAcceptAboveFields(receptionServiceReq);


                receptionServiceRes_1 = receptionServiceRes;
            }
        } else if ((reqDto != null && reqDto.getStandardDataCalcCycleModel() != null && reqDto.getStandardDataCalcCycleModel().equals("LAST_CYCLE") || reqDto != null && reqDto.getStandardDataCalcCycleModel() != null && reqDto.getStandardDataCalcCycleModel().equals("MID_OF_PROCESS_CYCLE") || reqDto != null && reqDto.getStandardDataCalcCycleModel() != null && reqDto.getStandardDataCalcCycleModel().equals("SUB_CYCLE"))) {
            //elseif((D3-执行获取目标内容子周期(公共).标准数据计算周期模型 等于 末级周期 or D3-执行获取目标内容子周期(公共).标准数据计算周期模型 等于 中间周期 or D3-执行获取目标内容子周期(公共).标准数据计算周期模型 等于 子周期))  44057

//ModelCode: receptionService
            CalculateAcceptAboveFieldsRespDto receptionServiceRes_2 = null;
            CalculateAcceptAboveFieldsReqDto receptionServiceReq_1 = new CalculateAcceptAboveFieldsReqDto();
            if (reqDto != null) {
                receptionServiceReq_1.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1006016_1_44059
            }

            /*约定出参：更新周期对应的目标周期ID[6495]  用于特殊方法接收上游入参。 */
            Assert.isNull(receptionServiceReq_1.getEvaObjTargetCycleId(), "D3-执行获取目标内容子周期(公共)-约定出参：更新周期对应的目标周期ID-被评对象目标周期ID不能为空", false);
            receptionServiceRes_2 = nbGridCalculate.calculateAcceptAboveFields(receptionServiceReq_1);


            receptionServiceRes_1 = receptionServiceRes_2;
        }
        ImplementFindSubTargetCycleComRespDto retData = new ImplementFindSubTargetCycleComRespDto();
        if (receptionServiceRes_1 != null) {
            retData.setEvaObjTargetCycleId(receptionServiceRes_1.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1006110_1
        }


        return retData;
    }

    /**
     * D3-执行与末级周期同体分析(公共)[7238]
     * gen by moon at 6/14/2024, 6:40:49 PM
     */
    @Trace(operationName = "D3-执行与末级周期同体分析(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementAnalysisSubCycleIsLastCycleComRespDto implementAnalysisSubCycleIsLastCycleCom(ImplementAnalysisSubCycleIsLastCycleComReqDto reqDto) {


        CalculateAcceptAboveFieldsRespDto receptionServiceRes_7 = null;
//virtualUsage 约定：正常（当前周期为末级周期）  62273
        //ModelCode: receptionService
        CalculateAcceptAboveFieldsRespDto receptionServiceRes = null;
        CalculateAcceptAboveFieldsReqDto receptionServiceReq = new CalculateAcceptAboveFieldsReqDto();
        receptionServiceReq.setSubCycleIsLastCycle("NORMAL");//sourceId:1572989_1_62273

        /*约定：正常（当前周期为末级周期）[6495]  用于特殊方法接收上游入参。 */
        Assert.isNull(receptionServiceReq.getSubCycleIsLastCycle(), "D3-执行与末级周期同体分析(公共)-约定：正常（当前周期为末级周期）-与末级周期同体类型分析结果不能为空", false);
        receptionServiceRes = nbGridCalculate.calculateAcceptAboveFields(receptionServiceReq);


//virtualUsage 约定：子周期与末级周期同体  62267
//ModelCode: receptionService
        CalculateAcceptAboveFieldsRespDto receptionServiceRes_2 = null;
        CalculateAcceptAboveFieldsReqDto receptionServiceReq_1 = new CalculateAcceptAboveFieldsReqDto();
        receptionServiceReq_1.setSubCycleIsLastCycle("SUB_CYCLE_SAME_AS_LAST_CYCLE_TYPE");//sourceId:1054697_1_62267

        /*约定：子周期与末级周期同体[6495]  用于特殊方法接收上游入参。 */
        Assert.isNull(receptionServiceReq_1.getSubCycleIsLastCycle(), "D3-执行与末级周期同体分析(公共)-约定：子周期与末级周期同体-与末级周期同体类型分析结果不能为空", false);
        receptionServiceRes_2 = nbGridCalculate.calculateAcceptAboveFields(receptionServiceReq_1);


//virtualUsage 约定：过程中间周期与末级周期同体  62268
        //ModelCode: receptionService
        CalculateAcceptAboveFieldsRespDto receptionServiceRes_4 = null;
        CalculateAcceptAboveFieldsReqDto receptionServiceReq_2 = new CalculateAcceptAboveFieldsReqDto();
        receptionServiceReq_2.setSubCycleIsLastCycle("MID_OF_PROCESS_SAME_AS_LAST_CYCLE_TYPE");//sourceId:1054699_1_62268

        /*约定：过程中间周期与末级周期同体[6495]  用于特殊方法接收上游入参。 */
        Assert.isNull(receptionServiceReq_2.getSubCycleIsLastCycle(), "D3-执行与末级周期同体分析(公共)-约定：过程中间周期与末级周期同体-与末级周期同体类型分析结果不能为空", false);
        receptionServiceRes_4 = nbGridCalculate.calculateAcceptAboveFields(receptionServiceReq_2);


        if ((reqDto != null && reqDto.getSecondLastCycleType() != null && reqDto.getSecondLastCycleType().equals("DISABLE"))) {
            //if(D3-执行与末级周期同体分析(公共).第二末级周期类型 等于 不启用)  62259

            ImplementStringEfficiencyCheckComRespDto implementStringEfficiencyCheckComRespDto = null;
            ImplementStringEfficiencyCheckComReqDto implementStringEfficiencyCheckComReqDto = new ImplementStringEfficiencyCheckComReqDto();
            if (reqDto != null) {
                implementStringEfficiencyCheckComReqDto.setReferenceString(reqDto.getCycleTypeCode());//SimpleFieldAssign//sourceId:1054077_1_62261
                implementStringEfficiencyCheckComReqDto.setComparisonString(reqDto.getLastCycleType());//SimpleFieldAssign//sourceId:1054078_1_62261
            }

            /*D2-执行字符串对比(公共)[5774]   */
            Assert.isNull(implementStringEfficiencyCheckComReqDto.getReferenceString(), "D3-执行与末级周期同体分析(公共)-D2-执行字符串对比(公共)-参照字符串不能为空", false);
            implementStringEfficiencyCheckComRespDto = interfaceModeService.implementStringEfficiencyCheckCom(implementStringEfficiencyCheckComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


            if ((implementStringEfficiencyCheckComRespDto != null && implementStringEfficiencyCheckComRespDto.getStringEfficiencyCheckResult() != null && implementStringEfficiencyCheckComRespDto.getStringEfficiencyCheckResult().equals("TRUE"))) {
                //if(D2-判断当前周期类型是否等于末级周期类型.字符串对比结果 等于 是)  62292

                ImplementStringEfficiencyCheckComRespDto implementStringEfficiencyCheckComRespDto_2 = null;
                ImplementStringEfficiencyCheckComReqDto implementStringEfficiencyCheckComReqDto_1 = new ImplementStringEfficiencyCheckComReqDto();
                if (reqDto != null) {
                    implementStringEfficiencyCheckComReqDto_1.setReferenceString(reqDto.getCycleTypeCode());//SimpleFieldAssign//sourceId:1054077_1_62304
                    implementStringEfficiencyCheckComReqDto_1.setComparisonString(reqDto.getSubcycleType());//SimpleFieldAssign//sourceId:1054078_1_62304
                }

                /*D2-执行字符串对比(公共)[5774]   */
                Assert.isNull(implementStringEfficiencyCheckComReqDto_1.getReferenceString(), "D3-执行与末级周期同体分析(公共)-D2-执行字符串对比(公共)-参照字符串不能为空", false);
                implementStringEfficiencyCheckComRespDto_2 = interfaceModeService.implementStringEfficiencyCheckCom(implementStringEfficiencyCheckComReqDto_1).getData()/*vcase invoke 跨dubbo调用;*/;


                if ((implementStringEfficiencyCheckComRespDto_2 != null && implementStringEfficiencyCheckComRespDto_2.getStringEfficiencyCheckResult() != null && implementStringEfficiencyCheckComRespDto_2.getStringEfficiencyCheckResult().equals("TRUE"))) {
                    //if(D2-判断当前周期类型是否等于子周期类型.字符串对比结果 等于 是)  62305

//ModelCode: receptionService
                    CalculateAcceptAboveFieldsRespDto receptionServiceRes_6 = null;
                    CalculateAcceptAboveFieldsReqDto receptionServiceReq_3 = new CalculateAcceptAboveFieldsReqDto();
                    if (receptionServiceRes_2 != null) {
                        receptionServiceReq_3.setSubCycleIsLastCycle(receptionServiceRes_2.getSubCycleIsLastCycle());//SimpleFieldAssign//sourceId:1054701_1_62306
                    }

                    /*约定出参：与末级周期同体分析结果[6495]  用于特殊方法接收上游入参。 */
                    Assert.isNull(receptionServiceReq_3.getSubCycleIsLastCycle(), "D3-执行与末级周期同体分析(公共)-约定出参：与末级周期同体分析结果-与末级周期同体类型分析结果不能为空", false);
                    receptionServiceRes_6 = nbGridCalculate.calculateAcceptAboveFields(receptionServiceReq_3);


                    receptionServiceRes_7 = receptionServiceRes_6;
                } else if ((implementStringEfficiencyCheckComRespDto_2 != null && implementStringEfficiencyCheckComRespDto_2.getStringEfficiencyCheckResult() != null && implementStringEfficiencyCheckComRespDto_2.getStringEfficiencyCheckResult().equals("FALSE"))) {
                    //elseif(D2-判断当前周期类型是否等于子周期类型.字符串对比结果 等于 否)  62307

//ModelCode: receptionService
                    CalculateAcceptAboveFieldsRespDto receptionServiceRes_8 = null;
                    CalculateAcceptAboveFieldsReqDto receptionServiceReq_4 = new CalculateAcceptAboveFieldsReqDto();
                    if (receptionServiceRes != null) {
                        receptionServiceReq_4.setSubCycleIsLastCycle(receptionServiceRes.getSubCycleIsLastCycle());//SimpleFieldAssign//sourceId:1054701_1_62308
                    }

                    /*约定出参：与末级周期同体分析结果[6495]  用于特殊方法接收上游入参。 */
                    Assert.isNull(receptionServiceReq_4.getSubCycleIsLastCycle(), "D3-执行与末级周期同体分析(公共)-约定出参：与末级周期同体分析结果-与末级周期同体类型分析结果不能为空", false);
                    receptionServiceRes_8 = nbGridCalculate.calculateAcceptAboveFields(receptionServiceReq_4);


                    receptionServiceRes_7 = receptionServiceRes_8;
                }
            } else if ((implementStringEfficiencyCheckComRespDto != null && implementStringEfficiencyCheckComRespDto.getStringEfficiencyCheckResult() != null && implementStringEfficiencyCheckComRespDto.getStringEfficiencyCheckResult().equals("FALSE"))) {
                //elseif(D2-判断当前周期类型是否等于末级周期类型.字符串对比结果 等于 否)  62293

//ModelCode: receptionService
                CalculateAcceptAboveFieldsRespDto receptionServiceRes_9 = null;
                CalculateAcceptAboveFieldsReqDto receptionServiceReq_5 = new CalculateAcceptAboveFieldsReqDto();
                if (receptionServiceRes != null) {
                    receptionServiceReq_5.setSubCycleIsLastCycle(receptionServiceRes.getSubCycleIsLastCycle());//SimpleFieldAssign//sourceId:1054701_1_62303
                }

                /*约定出参：与末级周期同体分析结果[6495]  用于特殊方法接收上游入参。 */
                Assert.isNull(receptionServiceReq_5.getSubCycleIsLastCycle(), "D3-执行与末级周期同体分析(公共)-约定出参：与末级周期同体分析结果-与末级周期同体类型分析结果不能为空", false);
                receptionServiceRes_9 = nbGridCalculate.calculateAcceptAboveFields(receptionServiceReq_5);


                receptionServiceRes_7 = receptionServiceRes_9;
            }
        } else if ((!(reqDto != null && reqDto.getSecondLastCycleType() != null && reqDto.getSecondLastCycleType().equals("DISABLE")))) {
            //elseif(D3-执行与末级周期同体分析(公共).第二末级周期类型 不等于 不启用)  62260

            ImplementStringEfficiencyCheckComRespDto implementStringEfficiencyCheckComRespDto_3 = null;
            ImplementStringEfficiencyCheckComReqDto implementStringEfficiencyCheckComReqDto_2 = new ImplementStringEfficiencyCheckComReqDto();
            if (reqDto != null) {
                implementStringEfficiencyCheckComReqDto_2.setReferenceString(reqDto.getCycleTypeCode());//SimpleFieldAssign//sourceId:1054077_1_62269
                implementStringEfficiencyCheckComReqDto_2.setComparisonString(reqDto.getSecondLastCycleType());//SimpleFieldAssign//sourceId:1054078_1_62269
            }

            /*D2-执行字符串对比(公共)[5774]   */
            Assert.isNull(implementStringEfficiencyCheckComReqDto_2.getReferenceString(), "D3-执行与末级周期同体分析(公共)-D2-执行字符串对比(公共)-参照字符串不能为空", false);
            implementStringEfficiencyCheckComRespDto_3 = interfaceModeService.implementStringEfficiencyCheckCom(implementStringEfficiencyCheckComReqDto_2).getData()/*vcase invoke 跨dubbo调用;*/;


            if ((implementStringEfficiencyCheckComRespDto_3 != null && implementStringEfficiencyCheckComRespDto_3.getStringEfficiencyCheckResult() != null && implementStringEfficiencyCheckComRespDto_3.getStringEfficiencyCheckResult().equals("TRUE"))) {
                //if(D2-判断当前周期类型是否第二末级周期类型.字符串对比结果 等于 是)  62270

                OmsCycle omsCycle = null;
                QueryTimeMatchCycleDetailReq queryTimeMatchCycleDetailReq = new QueryTimeMatchCycleDetailReq();
                queryTimeMatchCycleDetailReq.setCycleStartTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:1572998_1_62310
                queryTimeMatchCycleDetailReq.setCycleEndTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:1572999_1_62310
                queryTimeMatchCycleDetailReq.setIsArchive("FALSE");//sourceId:1573002_1_62310
                if (reqDto != null) {
                    queryTimeMatchCycleDetailReq.setCycleTypeCode(reqDto.getSecondLastCycleType());//SimpleFieldAssign//sourceId:1573000_1_62310
                }

                /*3-4-04查询时间匹配周期详情（开始小于结束大于）[4985]   */
                Assert.isNull(queryTimeMatchCycleDetailReq.getCycleStartTime(), "D3-执行与末级周期同体分析(公共)-3-4-04查询时间匹配周期详情（开始小于结束大于）-周期开始时间不能为空", false);
                Assert.isNull(queryTimeMatchCycleDetailReq.getCycleEndTime(), "D3-执行与末级周期同体分析(公共)-3-4-04查询时间匹配周期详情（开始小于结束大于）-周期结束时间不能为空", false);
                Assert.isNull(queryTimeMatchCycleDetailReq.getCycleTypeCode(), "D3-执行与末级周期同体分析(公共)-3-4-04查询时间匹配周期详情（开始小于结束大于）-周期类型标识不能为空", false);
                Assert.isNull(queryTimeMatchCycleDetailReq.getIsArchive(), "D3-执行与末级周期同体分析(公共)-3-4-04查询时间匹配周期详情（开始小于结束大于）-是否存档不能为空", false);
                omsCycle = mOmsCycleService.queryTimeMatchCycleDetail(queryTimeMatchCycleDetailReq)/*vcase invoke 本地 method 方法调用;*/;


                CheckTimeScopeSearchComRespDto checkTimeScopeSearchComRespDto = null;
                if (omsCycle != null) {
                    CheckTimeScopeSearchComReqDto checkTimeScopeSearchComReqDto = new CheckTimeScopeSearchComReqDto();
                    if (omsCycle != null) {
                        checkTimeScopeSearchComReqDto.setCurrentTime(omsCycle.getCycleStartTime());//SimpleFieldAssign//sourceId:1573014_1_62311
                    }
                    if (reqDto != null) {
                        checkTimeScopeSearchComReqDto.setCompareTime(reqDto.getCycleEndTime());//SimpleFieldAssign//sourceId:1573016_1_62311
                    }

                    /*D2两个时间对比大小(公共)[3297]   */
                    Assert.isNull(checkTimeScopeSearchComReqDto.getCurrentTime(), "D3-执行与末级周期同体分析(公共)-D2两个时间对比大小(公共)-当前时间不能为空", false);
                    Assert.isNull(checkTimeScopeSearchComReqDto.getCompareTime(), "D3-执行与末级周期同体分析(公共)-D2两个时间对比大小(公共)-比较时间不能为空", false);
                    checkTimeScopeSearchComRespDto = fwCompDivineDataClient.checkTimeScopeSearchCom(checkTimeScopeSearchComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


                }
                if ((checkTimeScopeSearchComRespDto != null && checkTimeScopeSearchComRespDto.getTimeCompareResult() != null && checkTimeScopeSearchComRespDto.getTimeCompareResult().equals("PRESENT") || checkTimeScopeSearchComRespDto != null && checkTimeScopeSearchComRespDto.getTimeCompareResult() != null && checkTimeScopeSearchComRespDto.getTimeCompareResult().equals("LATER"))) {
                    //if((D2第二末级周期的周期开始时间与入参更新周期结束时间对比.时间比较结果 等于 当前（等于） or D2第二末级周期的周期开始时间与入参更新周期结束时间对比.时间比较结果 等于 之后（大于）))  62275

//ModelCode: receptionService
                    CalculateAcceptAboveFieldsRespDto receptionServiceRes_10 = null;
                    CalculateAcceptAboveFieldsReqDto receptionServiceReq_6 = new CalculateAcceptAboveFieldsReqDto();
                    if (receptionServiceRes_4 != null) {
                        receptionServiceReq_6.setSubCycleIsLastCycle(receptionServiceRes_4.getSubCycleIsLastCycle());//SimpleFieldAssign//sourceId:1054701_1_62312
                    }

                    /*约定出参：与末级周期同体分析结果[6495]  用于特殊方法接收上游入参。 */
                    Assert.isNull(receptionServiceReq_6.getSubCycleIsLastCycle(), "D3-执行与末级周期同体分析(公共)-约定出参：与末级周期同体分析结果-与末级周期同体类型分析结果不能为空", false);
                    receptionServiceRes_10 = nbGridCalculate.calculateAcceptAboveFields(receptionServiceReq_6);


                    receptionServiceRes_7 = receptionServiceRes_10;
                }
            } else if ((implementStringEfficiencyCheckComRespDto_3 != null && implementStringEfficiencyCheckComRespDto_3.getStringEfficiencyCheckResult() != null && implementStringEfficiencyCheckComRespDto_3.getStringEfficiencyCheckResult().equals("FALSE"))) {
                //elseif(D2-判断当前周期类型是否第二末级周期类型.字符串对比结果 等于 否)  62309

//ModelCode: receptionService
                CalculateAcceptAboveFieldsRespDto receptionServiceRes_11 = null;
                CalculateAcceptAboveFieldsReqDto receptionServiceReq_7 = new CalculateAcceptAboveFieldsReqDto();
                if (receptionServiceRes != null) {
                    receptionServiceReq_7.setSubCycleIsLastCycle(receptionServiceRes.getSubCycleIsLastCycle());//SimpleFieldAssign//sourceId:1054701_1_62313
                }

                /*约定出参：与末级周期同体分析结果[6495]  用于特殊方法接收上游入参。 */
                Assert.isNull(receptionServiceReq_7.getSubCycleIsLastCycle(), "D3-执行与末级周期同体分析(公共)-约定出参：与末级周期同体分析结果-与末级周期同体类型分析结果不能为空", false);
                receptionServiceRes_11 = nbGridCalculate.calculateAcceptAboveFields(receptionServiceReq_7);


                receptionServiceRes_7 = receptionServiceRes_11;
            }
        } else {
            //else  62314

//异常结束 62315
            throw new BizException("C221000373", "对不起，末级周期类型与第二末级周期类型，找不到数据了~", false);
        }
        ImplementAnalysisSubCycleIsLastCycleComRespDto retData = new ImplementAnalysisSubCycleIsLastCycleComRespDto();
        if (receptionServiceRes_7 != null) {
            retData.setSubCycleIsLastCycle(receptionServiceRes_7.getSubCycleIsLastCycle());//SimpleFieldAssign//sourceId:1054703_1
        }


        return retData;
    }

    /**
     * D3-定时计算全网内容标准数据(公共)[6378]
     * gen by moon at 6/28/2023, 1:15:06 AM
     */
    @Trace(operationName = "D3-定时计算全网内容标准数据(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public TimingCalcAllDataComRespDto timingCalcAllDataCom(TimingCalcAllDataComReqDto reqDto) {


        //virtualUsage 3-2-09查询定时任务调度列表  40167
        List<OmsTargetTimingTaskDispatch> listOmsTargetTimingTaskDispatch = new ArrayList<>();
        QueryTimerTaskPlanListReq queryTimerTaskPlanListReq = new QueryTimerTaskPlanListReq();
        queryTimerTaskPlanListReq.setTaskDispatchTypeCode("CONTENT_SUBTASK");//sourceId:899953_1_40167
        queryTimerTaskPlanListReq.setDispatchActionTypeCode("DISPATCH_EXECUTE_GRID_CALC_TASK");//sourceId:899954_1_40167
        queryTimerTaskPlanListReq.setObjectTypeCode("OMS_EVALUATION_TEMPLATE");//sourceId:899955_1_40167
        queryTimerTaskPlanListReq.setAddRuleInfoTypeCode("OMS_CYCLE");//sourceId:899958_1_40167
        queryTimerTaskPlanListReq.setIsComplete("FALSE");//sourceId:899956_1_40167
        queryTimerTaskPlanListReq.setIsCompensateTask("FALSE");//sourceId:899952_1_40167

        /*3-2-09查询定时任务调度列表[3261]   */
        Assert.isNull(queryTimerTaskPlanListReq.getTaskDispatchTypeCode(), "D3-定时计算全网内容标准数据(公共)-3-2-09查询定时任务调度列表-任务调度类型编码不能为空", false);
        Assert.isNull(queryTimerTaskPlanListReq.getDispatchActionTypeCode(), "D3-定时计算全网内容标准数据(公共)-3-2-09查询定时任务调度列表-任务调度的行为类型编码不能为空", false);
        Assert.isNull(queryTimerTaskPlanListReq.getObjectTypeCode(), "D3-定时计算全网内容标准数据(公共)-3-2-09查询定时任务调度列表-归属对象类型编码不能为空", false);
        Assert.isNull(queryTimerTaskPlanListReq.getAddRuleInfoTypeCode(), "D3-定时计算全网内容标准数据(公共)-3-2-09查询定时任务调度列表-生成规则信息类型编码不能为空", false);
        Assert.isNull(queryTimerTaskPlanListReq.getIsComplete(), "D3-定时计算全网内容标准数据(公共)-3-2-09查询定时任务调度列表-是否执行完成不能为空", false);
        Assert.isNull(queryTimerTaskPlanListReq.getIsCompensateTask(), "D3-定时计算全网内容标准数据(公共)-3-2-09查询定时任务调度列表-是否补偿任务不能为空", false);
        listOmsTargetTimingTaskDispatch = mOmsTargetTimingTaskDispatchService.queryTimerTaskPlanList(queryTimerTaskPlanListReq)/*vcase invoke 本地 method 方法调用;*/;


        if ((listOmsTargetTimingTaskDispatch != null && listOmsTargetTimingTaskDispatch != null && listOmsTargetTimingTaskDispatch.size() > 0)) {
            //if(3-2-09查询定时任务调度列表.定时任务调度列表数据集条数 大于 0)  40168

            QueryAppDetailComRespDto queryAppDetailComRespDto = null;
            QueryAppDetailComReqDto queryAppDetailComReqDto = new QueryAppDetailComReqDto();
            queryAppDetailComReqDto.setAppCode("XSZ");//CUSTOM_CONVENTION//sourceId:899971_1_40169

            /*D1-2查询联盟应用详情(公共)[3268]   */

            queryAppDetailComRespDto = baseService.queryAppDetailCom(queryAppDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


            AddTimerTaskPlanComRespDto addTimerTaskPlanComRespDto = null;
            if (queryAppDetailComRespDto != null) {
                AddTimerTaskPlanComReqDto addTimerTaskPlanComReqDto = new AddTimerTaskPlanComReqDto();
                addTimerTaskPlanComReqDto.setIsCompensateTask("FALSE");//sourceId:900027_1_40170
                addTimerTaskPlanComReqDto.setDispatchActionTypeCode("PLT_DISPATCH_EXECUTE_GRID_CALC_TASK");//sourceId:900028_1_40170
                addTimerTaskPlanComReqDto.setTaskDispatchTypeCode("PROJECT_CONTROLLING_TASK");//sourceId:900029_1_40170
                addTimerTaskPlanComReqDto.setObjectTypeCode("UNION_APP");//sourceId:900030_1_40170
                addTimerTaskPlanComReqDto.setIsComplete("FALSE");//sourceId:900032_1_40170
                addTimerTaskPlanComReqDto.setIsRealTimeaSync("TRUE");//sourceId:900033_1_40170
                if (queryAppDetailComRespDto != null) {
                    addTimerTaskPlanComReqDto.setObjectId(queryAppDetailComRespDto.getAppId());//SimpleFieldAssign//sourceId:1059213_1_40170
                    addTimerTaskPlanComReqDto.setOperationInductionId(queryAppDetailComRespDto.getOperationInductionId());//SimpleFieldAssign//sourceId:900034_1_40170
                    addTimerTaskPlanComReqDto.setSpaceId(queryAppDetailComRespDto.getUniqueSpaceId());//SimpleFieldAssign//sourceId:900035_1_40170
                    addTimerTaskPlanComReqDto.setAppId(queryAppDetailComRespDto.getAppId());//SimpleFieldAssign//sourceId:900036_1_40170
                }

                /*D3新增定时任务调度(公共)[4995]   */
                Assert.isNull(addTimerTaskPlanComReqDto.getIsCompensateTask(), "D3-定时计算全网内容标准数据(公共)-D3新增定时任务调度(公共)-是否补偿任务不能为空", false);
                Assert.isNull(addTimerTaskPlanComReqDto.getDispatchActionTypeCode(), "D3-定时计算全网内容标准数据(公共)-D3新增定时任务调度(公共)-任务调度的行为类型编码不能为空", false);
                Assert.isNull(addTimerTaskPlanComReqDto.getTaskDispatchTypeCode(), "D3-定时计算全网内容标准数据(公共)-D3新增定时任务调度(公共)-任务调度类型编码不能为空", false);
                addTimerTaskPlanComRespDto = taskGenService.addTimerTaskPlanCom(addTimerTaskPlanComReqDto)/*vcase invoke isSameApp*/;


            }
//ModelCode: circulationCollections
            for (OmsTargetTimingTaskDispatch circulationCollectionsRes : listOmsTargetTimingTaskDispatch) {

                ImplementUnderpinningCalcGridDispatchComRespDto implementUnderpinningCalcGridDispatchComRespDto = null;
                ImplementUnderpinningCalcGridDispatchComReqDto implementUnderpinningCalcGridDispatchComReqDto = new ImplementUnderpinningCalcGridDispatchComReqDto();
                if (circulationCollectionsRes != null) {
                    implementUnderpinningCalcGridDispatchComReqDto.setTimingTaskDispatchId(circulationCollectionsRes.getTimingTaskDispatchId());//SimpleFieldAssign//sourceId:1070386_1_46600
                    implementUnderpinningCalcGridDispatchComReqDto.setEvaluationTemplateId(circulationCollectionsRes.getObjectId());//SimpleFieldAssign//sourceId:1070387_1_46600
                }

                /*D3-执行托底网格计算调度(公共)[7216]   */

//      implementUnderpinningCalcGridDispatchComRespDto = implementUnderpinningCalcGridDispatchCom(implementUnderpinningCalcGridDispatchComReqDto)/*vcase invoke 同服务,同domain*/;


//ModelCode: circulationEnd
            }

            boolean bOOLEAN;
            if (addTimerTaskPlanComRespDto != null) {
                OmsTargetTimingTaskDispatch omsTargetTimingTaskDispatch = new OmsTargetTimingTaskDispatch();
                omsTargetTimingTaskDispatch.setIsComplete("TRUE");//sourceId:900038_1_40176
                omsTargetTimingTaskDispatch.setOperateTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:900039_1_40176
                if (addTimerTaskPlanComRespDto != null) {
                    omsTargetTimingTaskDispatch.setTimingTaskDispatchId(addTimerTaskPlanComRespDto.getTimingTaskDispatchId());//SimpleFieldAssign//sourceId:900037_1_40176
                }

                /*3-2-09更新定时任务调度（总控任务）[3186]   */
                Assert.isNull(omsTargetTimingTaskDispatch.getTimingTaskDispatchId(), "D3-定时计算全网内容标准数据(公共)-3-2-09更新定时任务调度（总控任务）-定时任务调度记录ID不能为空", false);
                Assert.isNull(omsTargetTimingTaskDispatch.getIsComplete(), "D3-定时计算全网内容标准数据(公共)-3-2-09更新定时任务调度（总控任务）-是否执行完成不能为空", false);
                Assert.isNull(omsTargetTimingTaskDispatch.getOperateTime(), "D3-定时计算全网内容标准数据(公共)-3-2-09更新定时任务调度（总控任务）-操作时间不能为空", false);
                bOOLEAN = mOmsTargetTimingTaskDispatchService.refreshTimerTaskPlan(omsTargetTimingTaskDispatch)/*vcase invoke 本地 method 方法调用;*/;


            }
        }
        TimingCalcAllDataComRespDto retData = new TimingCalcAllDataComRespDto();


        return retData;
    }

    /**
     * 1111D3-发布批次重计算全模板标准数据(公共)[7078]
     * gen by moon at 6/16/2024, 3:02:51 AM
     */
    @Trace(operationName = "1111D3-发布批次重计算全模板标准数据(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementReleaseRecalcEvaTempAllDataComRespDto implementReleaseRecalcEvaTempAllDataCom(ImplementReleaseRecalcEvaTempAllDataComReqDto reqDto) {


        ImplementReleaseRecalcEvaTempAllDataComRespDto retData = new ImplementReleaseRecalcEvaTempAllDataComRespDto();


        return retData;
    }

    /**
     * D3分析汇报任务筛选父子中周期类型(公共)[7136]
     * gen by moon at 9/13/2024, 5:17:40 PM
     */
    @Trace(operationName = "D3分析汇报任务筛选父子中周期类型(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementFatherMidSubCycleAnalysisComRespDto implementFatherMidSubCycleAnalysisCom(ImplementFatherMidSubCycleAnalysisComReqDto reqDto) {


        CalculateAcceptAboveFieldsRespDto receptionServiceRes_3 = null;
//virtualUsage M3约定父中子过程周期类型  72821
        //ModelCode: receptionService
        ImplementElevenReceivingFieldRespDto receptionServiceRes = null;
        ImplementElevenReceivingFieldReqDto receptionServiceReq = new ImplementElevenReceivingFieldReqDto();
        receptionServiceReq.setCustomField1("PARENT_CYCLE");//CUSTOM_CONVENTION//sourceId:1999614_1_72821
        receptionServiceReq.setCustomField2("MID_CYCLE");//CUSTOM_CONVENTION//sourceId:1999615_1_72821
        receptionServiceReq.setCustomField3("SUB_CYCLE");//CUSTOM_CONVENTION//sourceId:1999616_1_72821
        receptionServiceReq.setCustomField4("PROCESS_CYCLE");//CUSTOM_CONVENTION//sourceId:1999617_1_72821

        /*M3约定父中子过程周期类型[9482]  用于特殊方法接收上游入参。 */
        Assert.isNull(receptionServiceReq.getCustomField1(), "D3分析汇报任务筛选父子中周期类型(公共)-M3约定父中子过程周期类型-自定义字段1不能为空", false);
        Assert.isNull(receptionServiceReq.getCustomField2(), "D3分析汇报任务筛选父子中周期类型(公共)-M3约定父中子过程周期类型-自定义字段2不能为空", false);
        Assert.isNull(receptionServiceReq.getCustomField3(), "D3分析汇报任务筛选父子中周期类型(公共)-M3约定父中子过程周期类型-自定义字段3不能为空", false);
        Assert.isNull(receptionServiceReq.getCustomField4(), "D3分析汇报任务筛选父子中周期类型(公共)-M3约定父中子过程周期类型-自定义字段4不能为空", false);
        receptionServiceRes = nbGridCalculate.implementElevenReceivingField(receptionServiceReq);


        if ((reqDto != null && reqDto.getIsFatherCycle() != null && reqDto.getIsFatherCycle().equals("TRUE") && reqDto != null && reqDto.getIsSubCycle() != null && reqDto.getIsSubCycle().equals("FALSE") && reqDto != null && reqDto.getIsMetaphase() != null && reqDto.getIsMetaphase().equals("FALSE"))) {
            //if((D3-执行父子中周期分析(公共).是否父周期 等于 是 and D3-执行父子中周期分析(公共).是否子周期 等于 否 and D3-执行父子中周期分析(公共).是否中期 等于 否))  44332

//ModelCode: receptionService
            CalculateAcceptAboveFieldsRespDto receptionServiceRes_2 = null;
            CalculateAcceptAboveFieldsReqDto receptionServiceReq_1 = new CalculateAcceptAboveFieldsReqDto();
            if (receptionServiceRes != null) {
                receptionServiceReq_1.setParentSubMidCycleType(receptionServiceRes.getCustomField1());//SimpleFieldAssign//sourceId:1999186_1_44333
            }

            /*约定出参[6495]  用于特殊方法接收上游入参。 */
            Assert.isNull(receptionServiceReq_1.getParentSubMidCycleType(), "D3分析汇报任务筛选父子中周期类型(公共)-约定出参-父子中过程周期类型不能为空", false);
            receptionServiceRes_2 = nbGridCalculate.calculateAcceptAboveFields(receptionServiceReq_1);


            receptionServiceRes_3 = receptionServiceRes_2;
        } else if ((reqDto != null && reqDto.getIsFatherCycle() != null && reqDto.getIsFatherCycle().equals("TRUE") && reqDto != null && reqDto.getIsSubCycle() != null && reqDto.getIsSubCycle().equals("TRUE") && reqDto != null && reqDto.getIsMetaphase() != null && reqDto.getIsMetaphase().equals("FALSE"))) {
            //elseif((D3-执行父子中周期分析(公共).是否父周期 等于 是 and D3-执行父子中周期分析(公共).是否子周期 等于 是 and D3-执行父子中周期分析(公共).是否中期 等于 否))  44334

//ModelCode: receptionService
            CalculateAcceptAboveFieldsRespDto receptionServiceRes_4 = null;
            CalculateAcceptAboveFieldsReqDto receptionServiceReq_2 = new CalculateAcceptAboveFieldsReqDto();
            if (reqDto != null) {
                receptionServiceReq_2.setCycleId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:1011202_1_44335
            }
            if (receptionServiceRes != null) {
                receptionServiceReq_2.setParentSubMidCycleType(receptionServiceRes.getCustomField1());//SimpleFieldAssign//sourceId:1999186_1_44335
            }

            /*约定出参[6495]  用于特殊方法接收上游入参。 */
            Assert.isNull(receptionServiceReq_2.getParentSubMidCycleType(), "D3分析汇报任务筛选父子中周期类型(公共)-约定出参-父子中过程周期类型不能为空", false);
            receptionServiceRes_4 = nbGridCalculate.calculateAcceptAboveFields(receptionServiceReq_2);


            receptionServiceRes_3 = receptionServiceRes_4;
        } else if ((reqDto != null && reqDto.getIsMetaphase() != null && reqDto.getIsMetaphase().equals("TRUE") && reqDto != null && reqDto.getIsFatherCycle() != null && reqDto.getIsFatherCycle().equals("FALSE") && reqDto != null && reqDto.getIsSubCycle() != null && reqDto.getIsSubCycle().equals("FALSE"))) {
            //elseif((D3-执行父子中周期分析(公共).是否中期 等于 是 and D3-执行父子中周期分析(公共).是否父周期 等于 否 and D3-执行父子中周期分析(公共).是否子周期 等于 否))  44336

//ModelCode: receptionService
            CalculateAcceptAboveFieldsRespDto receptionServiceRes_5 = null;
            CalculateAcceptAboveFieldsReqDto receptionServiceReq_3 = new CalculateAcceptAboveFieldsReqDto();
            if (receptionServiceRes != null) {
                receptionServiceReq_3.setParentSubMidCycleType(receptionServiceRes.getCustomField2());//SimpleFieldAssign//sourceId:1999186_1_44337
            }

            /*约定出参[6495]  用于特殊方法接收上游入参。 */
            Assert.isNull(receptionServiceReq_3.getParentSubMidCycleType(), "D3分析汇报任务筛选父子中周期类型(公共)-约定出参-父子中过程周期类型不能为空", false);
            receptionServiceRes_5 = nbGridCalculate.calculateAcceptAboveFields(receptionServiceReq_3);


            receptionServiceRes_3 = receptionServiceRes_5;
        } else if ((reqDto != null && reqDto.getIsSubCycle() != null && reqDto.getIsSubCycle().equals("TRUE") && reqDto != null && reqDto.getIsFatherCycle() != null && reqDto.getIsFatherCycle().equals("FALSE") && reqDto != null && reqDto.getIsMetaphase() != null && reqDto.getIsMetaphase().equals("FALSE"))) {
            //elseif((D3-执行父子中周期分析(公共).是否子周期 等于 是 and D3-执行父子中周期分析(公共).是否父周期 等于 否 and D3-执行父子中周期分析(公共).是否中期 等于 否))  72822

//ModelCode: receptionService
            CalculateAcceptAboveFieldsRespDto receptionServiceRes_6 = null;
            CalculateAcceptAboveFieldsReqDto receptionServiceReq_4 = new CalculateAcceptAboveFieldsReqDto();
            if (reqDto != null) {
                receptionServiceReq_4.setCycleId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:1011202_1_72823
            }
            if (receptionServiceRes != null) {
                receptionServiceReq_4.setParentSubMidCycleType(receptionServiceRes.getCustomField3());//SimpleFieldAssign//sourceId:1999186_1_72823
            }

            /*约定出参[6495]  用于特殊方法接收上游入参。 */
            Assert.isNull(receptionServiceReq_4.getParentSubMidCycleType(), "D3分析汇报任务筛选父子中周期类型(公共)-约定出参-父子中过程周期类型不能为空", false);
            receptionServiceRes_6 = nbGridCalculate.calculateAcceptAboveFields(receptionServiceReq_4);


            receptionServiceRes_3 = receptionServiceRes_6;
        } else if ((reqDto != null && reqDto.getIsFatherCycle() != null && reqDto.getIsFatherCycle().equals("FALSE") && reqDto != null && reqDto.getIsSubCycle() != null && reqDto.getIsSubCycle().equals("FALSE") && reqDto != null && reqDto.getIsMetaphase() != null && reqDto.getIsMetaphase().equals("FALSE"))) {
            //elseif((D3分析汇报任务筛选父子中周期类型(公共).是否父周期 等于 否 and D3分析汇报任务筛选父子中周期类型(公共).是否子周期 等于 否 and D3分析汇报任务筛选父子中周期类型(公共).是否中期 等于 否))  72824

//ModelCode: receptionService
            CalculateAcceptAboveFieldsRespDto receptionServiceRes_7 = null;
            CalculateAcceptAboveFieldsReqDto receptionServiceReq_5 = new CalculateAcceptAboveFieldsReqDto();
            if (reqDto != null) {
                receptionServiceReq_5.setCycleId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:1011202_1_72825
            }
            if (receptionServiceRes != null) {
                receptionServiceReq_5.setParentSubMidCycleType(receptionServiceRes.getCustomField4());//SimpleFieldAssign//sourceId:1999186_1_72825
            }

            /*约定出参[6495]  用于特殊方法接收上游入参。 */
            Assert.isNull(receptionServiceReq_5.getParentSubMidCycleType(), "D3分析汇报任务筛选父子中周期类型(公共)-约定出参-父子中过程周期类型不能为空", false);
            receptionServiceRes_7 = nbGridCalculate.calculateAcceptAboveFields(receptionServiceReq_5);


            receptionServiceRes_3 = receptionServiceRes_7;
        }
        ImplementFatherMidSubCycleAnalysisComRespDto retData = new ImplementFatherMidSubCycleAnalysisComRespDto();
        if (receptionServiceRes_3 != null) {
            retData.setCycleId(receptionServiceRes_3.getCycleId());//SimpleFieldAssign//sourceId:1011207_1
            retData.setParentSubMidCycleType(receptionServiceRes_3.getParentSubMidCycleType());//SimpleFieldAssign//sourceId:1999632_1
        }


        return retData;
    }

    //
}
